/*
 * SPDX-FileCopyrightText: 2023 UnionTech Software Technology Co., Ltd.
 *
 * SPDX-License-Identifier: MulanPSL-2.0
 */
#![allow(
    dead_code,
    non_camel_case_types,
    non_snake_case,
    non_upper_case_globals,
    unused_assignments,
    unused_mut,
    unused_variables,
    unused_unsafe,
    clippy::never_loop,
    clippy::unnecessary_literal_unwrap
)]
use crate::common::*;
extern "C" {
    fn stat(path:*const libc::c_char,buf:*mut stat) -> libc::c_int;
    static mut stdin: *mut FILE;
    static mut stdout: *mut FILE;
    static mut stderr: *mut FILE;
    fn snprintf(
        _: *mut libc::c_char,
        _: libc::c_ulong,
        _: *const libc::c_char,
        _: ...
    ) -> libc::c_int;
    fn getc(__stream: *mut FILE) -> libc::c_int;
    fn fread(
        _: *mut libc::c_void,
        _: libc::c_ulong,
        _: libc::c_ulong,
        _: *mut FILE,
    ) -> libc::c_ulong;
    fn fwrite(
        _: *const libc::c_void,
        _: libc::c_ulong,
        _: libc::c_ulong,
        _: *mut FILE,
    ) -> libc::c_ulong;
    fn clearerr(__stream: *mut FILE);
    fn feof(__stream: *mut FILE) -> libc::c_int;
    fn ferror(__stream: *mut FILE) -> libc::c_int;
    fn fileno(__stream: *mut FILE) -> libc::c_int;
    fn fprintf(_: *mut FILE, _: *const libc::c_char, _: ...) -> libc::c_int;
    fn fclose(__stream: *mut FILE) -> libc::c_int;
    fn memcpy(_: *mut libc::c_void, _: *const libc::c_void, _: libc::c_ulong) -> *mut libc::c_void;
    fn memset(_: *mut libc::c_void, _: libc::c_int, _: libc::c_ulong) -> *mut libc::c_void;
    fn strcmp(_: *const libc::c_char, _: *const libc::c_char) -> libc::c_int;
    fn strchr(_: *const libc::c_char, _: libc::c_int) -> *mut libc::c_char;
    fn strrchr(_: *const libc::c_char, _: libc::c_int) -> *mut libc::c_char;
    fn strlen(_: *const libc::c_char) -> libc::c_ulong;
    fn isatty(__fd: libc::c_int) -> libc::c_int;
    fn __errno_location() -> *mut libc::c_int;
    fn readdir(__dirp: *mut DIR) -> *mut dirent;
    fn closedir(__dirp: *mut DIR) -> libc::c_int;
    fn opendir(__name: *const libc::c_char) -> *mut DIR;
    fn qsort(__base: *mut libc::c_void, __nmemb: size_t, __size: size_t, __compar: __compar_fn_t);
    fn exit(_: libc::c_int) -> !;
    fn free(_: *mut libc::c_void);
    fn reallocarray(__ptr: *mut libc::c_void, __nmemb: size_t, __size: size_t)
        -> *mut libc::c_void;
    fn realloc(_: *mut libc::c_void, _: libc::c_ulong) -> *mut libc::c_void;
    fn malloc(_: libc::c_ulong) -> *mut libc::c_void;
    fn __ctype_b_loc() -> *mut *const libc::c_ushort;
    fn sudo_warn_gettext_v1(
        domainname: *const libc::c_char,
        msgid: *const libc::c_char,
    ) -> *mut libc::c_char;
    fn sudo_warn_nodebug_v1(fmt: *const libc::c_char, _: ...);
    fn sudo_warnx_nodebug_v1(fmt: *const libc::c_char, _: ...);
    static mut sudo_user: sudo_user;
    static mut sudoers_subsystem_ids: [libc::c_uint; 0];
    fn sudo_debug_exit_v1(
        func: *const libc::c_char,
        file: *const libc::c_char,
        line: libc::c_int,
        subsys: libc::c_int,
    );
    fn rcstr_alloc(len: size_t) -> *mut libc::c_char;
    fn open_sudoers(_: *const libc::c_char, _: bool, _: *mut bool) -> *mut FILE;
    static mut sudoers_warnings: bool;
    fn rcstr_delref(s: *const libc::c_char);
    fn sudo_secure_dir_v1(
        path: *const libc::c_char,
        uid: uid_t,
        gid: gid_t,
        sbp: *mut stat,
    ) -> libc::c_int;
    fn sudo_debug_exit_bool_v1(
        func: *const libc::c_char,
        file: *const libc::c_char,
        line: libc::c_int,
        subsys: libc::c_int,
        ret: bool,
    );
    fn sudo_debug_exit_int_v1(
        func: *const libc::c_char,
        file: *const libc::c_char,
        line: libc::c_int,
        subsys: libc::c_int,
        ret: libc::c_int,
    );
    fn sudo_debug_exit_str_v1(
        func: *const libc::c_char,
        file: *const libc::c_char,
        line: libc::c_int,
        subsys: libc::c_int,
        ret: *const libc::c_char,
    );
    fn sudo_debug_printf2_v1(
        func: *const libc::c_char,
        file: *const libc::c_char,
        line: libc::c_int,
        level: libc::c_int,
        fmt: *const libc::c_char,
        _: ...
    );
    fn append(_: *const libc::c_char, _: size_t) -> bool;
    fn fill_args(_: *const libc::c_char, _: size_t, _: libc::c_int) -> bool;
    fn fill_cmnd(_: *const libc::c_char, _: size_t) -> bool;
    fn fill_txt(_: *const libc::c_char, _: size_t, _: size_t) -> bool;
    fn ipv6_valid(s: *const libc::c_char) -> bool;
    fn sudoerserror(_: *const libc::c_char);
    static mut sudoerslval: YYSTYPE;
    fn sudo_digest_getlen_v1(digest_type_0: libc::c_int) -> libc::c_int;
    fn sudo_lbuf_init_v1(
        lbuf: *mut sudo_lbuf,
        output: sudo_lbuf_output_t,
        indent: libc::c_int,
        continuation: *const libc::c_char,
        cols: libc::c_int,
    );
    fn sudo_lbuf_append_v1(lbuf: *mut sudo_lbuf, fmt: *const libc::c_char, _: ...) -> bool;
}

pub const INITIAL: libc::c_int = 0;
pub const MAX_SUDOERS_DEPTH: libc::c_ulong = 128;
pub const SUDOERS_STACK_INCREMENT: libc::c_ulong = 16;

pub type __compar_fn_t =
    Option<unsafe extern "C" fn(*const libc::c_void, *const libc::c_void) -> libc::c_int>;
pub type flex_int16_t = int16_t;
pub type flex_int32_t = int32_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct yy_buffer_state {
    pub yy_input_file: *mut FILE,
    pub yy_ch_buf: *mut libc::c_char,
    pub yy_buf_pos: *mut libc::c_char,
    pub yy_buf_size: yy_size_t,
    pub yy_n_chars: yy_size_t,
    pub yy_is_our_buffer: libc::c_int,
    pub yy_is_interactive: libc::c_int,
    pub yy_at_bol: libc::c_int,
    pub yy_bs_lineno: libc::c_int,
    pub yy_bs_column: libc::c_int,
    pub yy_fill_buffer: libc::c_int,
    pub yy_buffer_status: libc::c_int,
}
pub type yy_size_t = size_t;
pub type YY_BUFFER_STATE = *mut yy_buffer_state;
pub type YY_CHAR = libc::c_uchar;
pub type yy_state_type = libc::c_int;

#[derive(Copy, Clone, BitfieldStruct)]
#[repr(C)]
pub struct cmndtag {
    #[bitfield(name = "nopasswd", ty = "libc::c_int", bits = "0..=2")]
    #[bitfield(name = "noexec", ty = "libc::c_int", bits = "3..=5")]
    #[bitfield(name = "setenv", ty = "libc::c_int", bits = "6..=8")]
    #[bitfield(name = "log_input", ty = "libc::c_int", bits = "9..=11")]
    #[bitfield(name = "log_output", ty = "libc::c_int", bits = "12..=14")]
    #[bitfield(name = "send_mail", ty = "libc::c_int", bits = "15..=17")]
    #[bitfield(name = "follow", ty = "libc::c_int", bits = "18..=20")]
    pub nopasswd_noexec_setenv_log_input_log_output_send_mail_follow: [u8; 3],
    #[bitfield(padding)]
    pub c2rust_padding: [u8; 1],
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct runascontainer {
    pub runasusers: *mut member,
    pub runasgroups: *mut member,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct include_stack {
    pub bs: YY_BUFFER_STATE,
    pub path: *mut libc::c_char,
    pub more: path_list_head,
    pub lineno: libc::c_int,
    pub keepopen: bool,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct path_list_head {
    pub slh_first: *mut path_list,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct path_list {
    pub entries: C2RustUnnamed_4,
    pub path: *mut libc::c_char,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct C2RustUnnamed_4 {
    pub sle_next: *mut path_list,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct sudo_lbuf {
    pub output: Option<unsafe extern "C" fn(*const libc::c_char) -> libc::c_int>,
    pub buf: *mut libc::c_char,
    pub continuation: *const libc::c_char,
    pub indent: libc::c_int,
    pub len: libc::c_int,
    pub size: libc::c_int,
    pub cols: libc::c_short,
    pub error: libc::c_short,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub struct sudo_user {
    pub pw: *mut passwd,
    pub _runas_pw: *mut passwd,
    pub _runas_gr: *mut group,
    pub cmnd_stat: *mut stat,
    pub name: *mut libc::c_char,
    pub path: *mut libc::c_char,
    pub tty: *mut libc::c_char,
    pub ttypath: *mut libc::c_char,
    pub host: *mut libc::c_char,
    pub shost: *mut libc::c_char,
    pub runhost: *mut libc::c_char,
    pub srunhost: *mut libc::c_char,
    pub prompt: *mut libc::c_char,
    pub cmnd: *mut libc::c_char,
    pub cmnd_args: *mut libc::c_char,
    pub cmnd_base: *mut libc::c_char,
    pub cmnd_safe: *mut libc::c_char,
    pub class_name: *mut libc::c_char,
    pub krb5_ccname: *mut libc::c_char,
    pub gid_list: *mut gid_list,
    pub env_vars: *const *mut libc::c_char,
    pub role: *mut libc::c_char,
    pub type_0: *mut libc::c_char,
    pub cwd: *const libc::c_char,
    pub iolog_file: *mut libc::c_char,
    pub gids: *mut gid_t,
    pub execfd: libc::c_int,
    pub ngids: libc::c_int,
    pub closefrom: libc::c_int,
    pub lines: libc::c_int,
    pub cols: libc::c_int,
    pub flags: libc::c_int,
    pub max_groups: libc::c_int,
    pub timeout: libc::c_int,
    pub umask: mode_t,
    pub uid: uid_t,
    pub gid: uid_t,
    pub sid: pid_t,
}
pub type sudo_lbuf_output_t = Option<unsafe extern "C" fn(*const libc::c_char) -> libc::c_int>;
#[derive(Copy, Clone)]
#[repr(C)]
pub union YYSTYPE {
    pub cmndspec: *mut cmndspec,
    pub defaults: *mut defaults,
    pub member: *mut member,
    pub runas: *mut runascontainer,
    pub privilege: *mut privilege,
    pub digest: *mut command_digest,
    pub command: sudo_command,
    pub options: command_options,
    pub tag: cmndtag,
    pub string: *mut libc::c_char,
    pub tok: libc::c_int,
}
#[no_mangle]
pub static mut sudolineno: libc::c_int = 0;
#[no_mangle]
pub static mut last_token: libc::c_int = 0;
#[no_mangle]
pub static mut sudoers: *mut libc::c_char = 0 as *const libc::c_char as *mut libc::c_char;
#[no_mangle]
pub static mut sudoers_file: *const libc::c_char =
    b"/etc/utsudoers\0" as *const u8 as *const libc::c_char;
#[no_mangle]
pub static mut sudoers_mode: mode_t = 0o440 as libc::c_int as mode_t;
#[no_mangle]
pub static mut sudoers_uid: uid_t = 0 as libc::c_int as uid_t;
#[no_mangle]
pub static mut sudoers_gid: gid_t = 0 as libc::c_int as gid_t;
static mut continued: bool = false;
static mut sawspace: bool = false;
static mut prev_state: libc::c_int = 0;
static mut digest_type: libc::c_int = -(1 as libc::c_int);
#[no_mangle]
pub static mut trace_print: Option<unsafe extern "C" fn(*const libc::c_char) -> libc::c_int> = unsafe {
    Some(sudoers_trace_print as unsafe extern "C" fn(*const libc::c_char) -> libc::c_int)
};
static mut yy_buffer_stack_top: size_t = 0 as libc::c_int as size_t;
static mut yy_buffer_stack_max: size_t = 0 as libc::c_int as size_t;
static mut yy_buffer_stack: *mut YY_BUFFER_STATE =
    0 as *const YY_BUFFER_STATE as *mut YY_BUFFER_STATE;
static mut yy_hold_char: libc::c_char = 0;
static mut yy_n_chars: yy_size_t = 0;
#[no_mangle]
pub static mut sudoersleng: yy_size_t = 0;
static mut yy_c_buf_p: *mut libc::c_char = 0 as *const libc::c_char as *mut libc::c_char;
static mut yy_init: libc::c_int = 0 as libc::c_int;
static mut yy_start: libc::c_int = 0 as libc::c_int;
static mut yy_did_buffer_switch_on_eof: libc::c_int = 0;
#[no_mangle]
pub static mut sudoersin: *mut FILE = 0 as *const FILE as *mut FILE;
#[no_mangle]
pub static mut sudoersout: *mut FILE = 0 as *const FILE as *mut FILE;
#[no_mangle]
pub static mut sudoerslineno: libc::c_int = 1 as libc::c_int;
static mut yy_accept: [flex_int16_t; 896] = [
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 75, 62, 70, 69, 73, 68, 61, 72, 38, 63, 64, 38,
    65, 62, 62, 62, 62, 67, 66, 73, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 73, 62, 62, 70,
    72, 53, 53, 53, 53, 53, 2, 73, 1, 62, 53, 53, 53, 62, 17, 16, 16, 17, 16, 16, 73, 72, 73, 3, 9,
    8, 9, 4, 9, 5, 73, 13, 13, 13, 11, 12, 73, 19, 19, 18, 18, 18, 19, 18, 18, 18, 18, 19, 19, 19,
    19, 19, 19, 18, 19, 19, 62, 0, 70, 69, 68, 72, 72, 0, 0, 62, 40, 0, 38, 0, 39, 0, 60, 60, 0,
    62, 62, 0, 62, 62, 62, 62, 0, 43, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53,
    0, 71, 62, 62, 62, 62, 70, 0, 0, 0, 0, 0, 72, 62, 62, 62, 62, 62, 2, 1, 0, 1, 54, 54, 0, 53,
    62, 17, 17, 15, 0, 14, 15, 0, 3, 9, 0, 6, 7, 9, 9, 13, 0, 13, 13, 0, 10, 0, 40, 0, 0, 39, 19,
    19, 0, 19, 0, 0, 18, 18, 18, 18, 18, 18, 19, 19, 53, 19, 19, 19, 19, 19, 19, 19, 19, 19, 72,
    72, 72, 0, 40, 62, 62, 62, 62, 62, 0, 0, 43, 43, 53, 45, 53, 53, 53, 53, 53, 53, 53, 53, 53,
    53, 53, 53, 53, 53, 53, 53, 53, 53, 62, 62, 0, 0, 0, 0, 0, 72, 62, 62, 62, 62, 62, 0, 62, 10,
    0, 0, 0, 18, 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 72, 72, 72,
    62, 62, 62, 62, 62, 62, 0, 44, 44, 44, 0, 0, 43, 43, 43, 43, 43, 43, 43, 53, 53, 53, 53, 53,
    53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 49, 53, 53, 50, 62, 62, 62, 62, 0, 0, 0, 0, 0, 72,
    62, 62, 62, 62, 0, 0, 0, 0, 0, 18, 18, 19, 19, 53, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
    19, 19, 62, 62, 62, 0, 0, 44, 44, 44, 0, 43, 43, 0, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
    0, 27, 53, 53, 53, 53, 0, 34, 53, 53, 53, 53, 53, 53, 53, 53, 53, 51, 53, 53, 62, 62, 62, 62,
    62, 0, 0, 0, 72, 62, 62, 62, 0, 0, 0, 18, 18, 19, 53, 53, 19, 19, 19, 19, 19, 19, 19, 19, 19,
    19, 19, 19, 19, 62, 62, 62, 62, 62, 0, 44, 0, 43, 43, 43, 0, 0, 0, 43, 43, 43, 43, 43, 43, 43,
    43, 43, 43, 43, 43, 43, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 53, 55, 56, 57,
    58, 62, 0, 0, 72, 62, 62, 62, 0, 0, 0, 0, 0, 19, 53, 53, 19, 19, 53, 19, 19, 19, 19, 19, 19,
    19, 19, 19, 19, 41, 41, 41, 0, 0, 43, 43, 43, 43, 43, 43, 43, 0, 0, 0, 0, 0, 43, 43, 43, 43,
    43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 0, 36, 53, 53, 53, 0, 26, 53, 53, 53, 0, 35, 53, 53,
    53, 53, 0, 25, 0, 28, 46, 62, 0, 0, 72, 62, 62, 62, 41, 41, 41, 53, 53, 19, 53, 53, 19, 19, 19,
    62, 41, 41, 41, 41, 0, 43, 0, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 0, 0, 0, 43, 43, 43,
    43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 53, 53, 53, 53, 53, 53, 53, 53, 48, 53, 59, 0, 0, 72,
    62, 22, 54, 0, 41, 41, 41, 41, 53, 53, 19, 53, 53, 19, 19, 19, 42, 42, 42, 42, 43, 0, 0, 0, 43,
    43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 0, 0, 0, 0, 0, 43, 43, 43, 43, 43, 43, 43, 43,
    53, 53, 53, 0, 37, 53, 53, 0, 24, 0, 29, 47, 0, 22, 72, 72, 62, 0, 62, 42, 42, 42, 42, 53, 53,
    53, 53, 62, 62, 42, 42, 42, 42, 0, 0, 0, 0, 0, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43,
    43, 43, 43, 43, 43, 43, 43, 43, 52, 0, 32, 53, 53, 53, 0, 72, 72, 20, 72, 72, 23, 22, 0, 0, 0,
    0, 0, 22, 0, 0, 0, 42, 42, 42, 42, 53, 53, 53, 62, 62, 62, 0, 0, 0, 43, 43, 43, 43, 43, 43, 43,
    43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 0, 30, 53, 53, 23, 20, 72, 0, 22, 0, 0, 0, 53, 53,
    62, 62, 62, 62, 62, 0, 0, 0, 0, 0, 43, 43, 43, 43, 43, 43, 43, 43, 0, 33, 53, 72, 0, 0, 0, 0,
    0, 53, 62, 62, 62, 43, 43, 43, 43, 43, 43, 0, 31, 72, 72, 21, 72, 0, 0, 0, 62, 62, 62, 62, 62,
    43, 43, 43, 43, 43, 21, 0, 0, 0, 0, 0, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 0,
];
static mut yy_ec: [flex_int32_t; 256] = [
    0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    5, 6, 7, 8, 1, 9, 1, 1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
    28, 1, 1, 29, 30, 12, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 41, 42, 43, 44, 45, 46, 41,
    47, 48, 49, 50, 51, 52, 53, 54, 41, 12, 55, 12, 1, 56, 1, 57, 58, 59, 60, 61, 62, 63, 64, 65,
    63, 63, 66, 67, 68, 69, 63, 63, 70, 71, 72, 73, 63, 63, 63, 63, 63, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
];
static mut yy_meta: [flex_int32_t; 74] = [
    0, 1, 2, 3, 3, 2, 4, 5, 6, 1, 7, 7, 1, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13,
    13, 14, 15, 7, 1, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
    17, 17, 17, 17, 18, 19, 20, 20, 20, 20, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
];
static mut yy_base: [flex_int16_t; 1020] = [
    0, 0, 72, 121, 191, 81, 88, 261, 333, 405, 459, 142, 148, 514, 0, 4774, 4718, 73, 6207, 4769,
    4765, 6207, 585, 73, 6207, 6207, 4715, 6207, 151, 597, 153, 164, 4741, 6207, 6207, 659, 4726,
    46, 34, 715, 58, 4724, 4710, 50, 4709, 4717, 60, 776, 791, 57, 189, 816, 66, 63, 4683, 59,
    4680, 113, 4735, 129, 204, 4704, 4703, 4715, 134, 0, 6207, 4743, 4739, 6207, 0, 880, 933, 137,
    0, 4689, 6207, 135, 6207, 140, 6207, 214, 4688, 154, 194, 6207, 239, 193, 259, 960, 1004, 258,
    232, 1062, 1112, 4700, 160, 180, 1168, 4696, 4708, 4694, 4706, 4701, 1215, 0, 156, 4681, 1239,
    225, 6207, 4729, 228, 6207, 4731, 273, 283, 4678, 4717, 332, 1266, 4676, 1293, 415, 4675, 1322,
    1335, 1375, 4681, 4681, 324, 343, 334, 4657, 228, 1437, 1493, 4631, 4625, 4607, 4594, 4587,
    4573, 335, 4553, 4549, 4535, 4516, 4514, 4510, 371, 6207, 157, 425, 215, 65, 442, 4488, 4493,
    4484, 4479, 4480, 355, 218, 369, 133, 369, 325, 434, 256, 431, 377, 584, 4495, 1554, 448, 378,
    0, 4543, 412, 4545, 6207, 6207, 479, 0, 4492, 633, 6207, 6207, 4491, 438, 4490, 4537, 591, 440,
    505, 430, 4540, 736, 737, 659, 4487, 843, 0, 1581, 1611, 794, 842, 1650, 4525, 892, 902, 740,
    1700, 1756, 4498, 0, 4503, 4490, 4493, 4490, 752, 4481, 4469, 4448, 4433, 308, 465, 475, 920,
    959, 1803, 974, 748, 1843, 4465, 4441, 1888, 454, 1934, 1979, 0, 4423, 4410, 4411, 4394, 4407,
    4395, 4402, 4401, 4413, 4412, 4407, 454, 4394, 4390, 4404, 4402, 4401, 4398, 825, 573, 4357,
    4362, 4352, 4354, 4360, 594, 588, 4363, 572, 232, 581, 1098, 778, 597, 4403, 4402, 2026, 2036,
    4401, 2081, 0, 4382, 4373, 4358, 4371, 4358, 4365, 4362, 4326, 4325, 4320, 4294, 4303, 733,
    4269, 6207, 508, 646, 2126, 730, 0, 0, 800, 773, 4308, 4307, 2164, 831, 4306, 4305, 609, 984,
    2177, 1193, 882, 2223, 2270, 4304, 851, 4286, 4281, 830, 960, 4271, 4257, 4260, 4257, 4248,
    4246, 4257, 4246, 4229, 4226, 0, 4229, 4227, 0, 834, 111, 774, 606, 4211, 4197, 4181, 4195,
    4159, 946, 821, 1193, 404, 742, 1236, 4212, 4211, 4199, 1095, 2280, 2325, 1100, 4157, 833,
    1204, 4163, 4156, 4159, 4156, 4147, 4145, 4141, 4118, 867, 4133, 4139, 4096, 2372, 2384, 2396,
    4128, 4127, 2406, 4127, 4125, 4084, 4060, 804, 1263, 879, 1290, 1076, 2419, 0, 1321, 2466,
    1345, 1355, 2512, 2559, 1377, 6207, 4028, 4033, 4034, 4027, 1378, 6207, 4031, 4022, 4007, 4020,
    4007, 4018, 4004, 3998, 3993, 0, 3959, 3959, 875, 202, 909, 851, 908, 3952, 3923, 3912, 1219,
    1220, 1142, 958, 3955, 3952, 2571, 2581, 2626, 3915, 3922, 3915, 3930, 3921, 3906, 3889, 3863,
    3851, 3851, 3821, 3849, 3846, 3846, 3839, 3753, 2671, 877, 2711, 2723, 1515, 3770, 3767, 3766,
    3746, 2733, 1274, 3750, 3746, 2780, 1303, 1318, 1397, 1397, 1411, 2792, 0, 1580, 2839, 1521,
    1366, 2885, 2932, 2959, 1588, 1602, 1629, 1438, 1634, 1653, 1439, 1792, 1686, 1623, 1803, 1687,
    1804, 1805, 3701, 3694, 3684, 3664, 1036, 3670, 3627, 1139, 1326, 1152, 1467, 1553, 3640, 3632,
    3631, 1681, 1832, 3585, 3553, 1844, 3532, 974, 1845, 3512, 3507, 1869, 1889, 0, 0, 0, 0, 3483,
    3016, 1863, 1780, 3456, 3426, 3402, 1908, 3056, 1954, 1820, 3101, 3148, 1999, 3398, 3340, 3321,
    1920, 1414, 1577, 1616, 1621, 2056, 1636, 3160, 0, 2103, 3207, 2136, 1964, 3253, 3300, 1890,
    6207, 3327, 1517, 1279, 1891, 6207, 1253, 1407, 1574, 2082, 6207, 1610, 1603, 1566, 1616, 2083,
    6207, 2084, 6207, 3277, 1494, 3243, 3236, 1106, 1564, 1374, 1732, 3266, 3245, 3384, 3166, 3163,
    3399, 3164, 3140, 1760, 882, 3093, 3455, 1882, 3494, 0, 2003, 3103, 3084, 2146, 1290, 2197,
    1553, 3534, 0, 2245, 3547, 2300, 2114, 3592, 3639, 3095, 3090, 3651, 1677, 1678, 2015, 2259,
    3088, 2337, 3663, 0, 2350, 3710, 2439, 2156, 3757, 3784, 1296, 923, 2226, 1614, 1802, 2328,
    2467, 3036, 1228, 3031, 3005, 2992, 2502, 1800, 2626, 3000, 2490, 2971, 2956, 2952, 2533, 2916,
    2899, 3856, 2886, 2882, 2224, 2225, 0, 3914, 2601, 2646, 1945, 2866, 2871, 2863, 3954, 2850,
    2246, 2347, 2841, 2348, 3966, 0, 2683, 3979, 2694, 2545, 4024, 4071, 2753, 2828, 2807, 2781,
    2765, 1768, 1828, 2805, 1018, 1043, 4083, 0, 2818, 2079, 2468, 1939, 2306, 6207, 1057, 2285,
    2327, 6207, 2469, 6207, 2738, 2725, 2603, 2267, 2063, 1625, 2840, 2875, 2747, 2659, 4095, 2541,
    2672, 2886, 2887, 2888, 4105, 1508, 4145, 0, 2683, 1700, 3026, 2639, 2620, 2594, 3038, 2530,
    2514, 2361, 2385, 3076, 2560, 4185, 0, 3123, 4198, 3180, 2905, 4243, 4290, 2504, 2458, 4301,
    2815, 2311, 1630, 4328, 2934, 6207, 2961, 2229, 2183, 2154, 1832, 2720, 6207, 2005, 2608, 2125,
    2054, 3102, 2878, 2224, 2050, 4398, 1980, 4425, 3227, 1994, 1973, 1928, 3046, 1882, 3208, 3209,
    3210, 4440, 4452, 4464, 1836, 1795, 4476, 1758, 1703, 2712, 2913, 3273, 3057, 4488, 0, 3467,
    4501, 3478, 3283, 4548, 1673, 1644, 1598, 3312, 1506, 3254, 6207, 3279, 1399, 6207, 6207, 3145,
    3504, 3514, 1410, 1388, 4560, 3593, 3594, 4572, 2074, 4584, 4596, 3685, 3567, 1332, 1262, 1249,
    3614, 1223, 1170, 3124, 1063, 971, 4608, 0, 3129, 3595, 6207, 3640, 3489, 3691, 875, 814, 739,
    3732, 3736, 4620, 4632, 4644, 3924, 3934, 3999, 617, 0, 585, 3758, 6207, 2030, 3504, 6207,
    2088, 576, 497, 4656, 4668, 2319, 4680, 4692, 4011, 6207, 4049, 4115, 3524, 6207, 6207, 4125,
    467, 297, 231, 3844, 4702, 4740, 4778, 4155, 4165, 4218, 58, 4816, 4228, 6207, 4266, 3769,
    6207, 4871, 4892, 4913, 4934, 4955, 4976, 4997, 5018, 5039, 5048, 2666, 5068, 5089, 2187, 5110,
    5131, 5152, 5173, 5194, 5215, 5236, 5257, 5278, 2957, 5299, 5320, 5341, 5350, 5358, 5367, 5387,
    5408, 5429, 2429, 5450, 5471, 5492, 5513, 5534, 5543, 5562, 5571, 5580, 2509, 2530, 5588, 5596,
    5604, 5613, 5621, 5628, 5636, 5644, 5653, 5663, 2624, 2669, 5671, 5679, 5687, 2751, 2857, 5696,
    5706, 5726, 2927, 5735, 5743, 3119, 5752, 5762, 5782, 2297, 2368, 5791, 5803, 5812, 5822, 3178,
    3244, 5831, 5841, 5850, 5870, 2455, 5879, 5891, 3250, 3344, 5900, 5910, 5918, 3402, 5927, 5937,
    5957, 5978, 5999, 3416, 3565, 6019, 3590, 6026, 6036, 2617, 2818, 6045, 6065, 6086, 6107, 3328,
    6128, 3627, 3628, 6137, 6147, 3633, 3681, 6155, 6165, 6185, 3745, 3746, 3801,
];
static mut yy_def: [flex_int16_t; 1020] = [
    0, 895, 1, 1, 1, 896, 896, 897, 897, 898, 898, 899, 899, 895, 13, 895, 900, 895, 895, 895, 895,
    895, 901, 902, 895, 895, 903, 895, 904, 900, 29, 29, 905, 895, 895, 895, 35, 35, 35, 35, 39,
    39, 39, 39, 39, 39, 39, 900, 29, 900, 895, 901, 35, 35, 39, 39, 39, 895, 906, 895, 907, 39, 39,
    39, 900, 908, 895, 895, 908, 895, 908, 895, 901, 895, 909, 910, 895, 910, 895, 910, 895, 911,
    912, 912, 912, 895, 895, 913, 914, 915, 895, 90, 90, 90, 895, 94, 94, 94, 94, 98, 98, 98, 98,
    98, 90, 93, 93, 900, 900, 895, 895, 895, 916, 895, 895, 917, 895, 918, 919, 913, 918, 920, 920,
    921, 922, 900, 900, 900, 923, 127, 127, 127, 127, 924, 925, 895, 135, 136, 136, 136, 136, 136,
    136, 136, 136, 136, 136, 136, 136, 136, 895, 895, 900, 900, 900, 900, 895, 895, 895, 895, 895,
    895, 916, 900, 127, 900, 900, 900, 895, 895, 895, 895, 926, 927, 900, 136, 900, 928, 928, 895,
    895, 895, 895, 917, 929, 930, 930, 895, 895, 930, 930, 931, 895, 931, 931, 895, 895, 895, 913,
    913, 913, 932, 933, 93, 932, 934, 895, 895, 90, 208, 208, 208, 208, 895, 213, 214, 935, 214,
    214, 214, 214, 214, 214, 214, 93, 93, 916, 916, 936, 895, 895, 900, 231, 231, 127, 234, 937,
    895, 938, 895, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
    136, 136, 136, 136, 900, 900, 895, 895, 895, 895, 895, 916, 900, 234, 900, 900, 900, 895, 900,
    895, 939, 940, 895, 93, 279, 213, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214,
    214, 93, 93, 895, 936, 936, 900, 900, 231, 231, 231, 900, 941, 942, 942, 308, 943, 942, 944,
    239, 895, 314, 314, 895, 314, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
    136, 136, 136, 136, 136, 136, 136, 900, 900, 900, 900, 895, 895, 895, 895, 895, 916, 900, 900,
    900, 900, 895, 895, 939, 939, 895, 279, 213, 214, 214, 945, 214, 214, 214, 214, 214, 214, 214,
    214, 214, 93, 93, 93, 93, 231, 231, 231, 895, 946, 946, 381, 946, 947, 948, 949, 895, 950, 317,
    950, 895, 391, 950, 895, 394, 394, 895, 394, 895, 895, 136, 136, 136, 136, 895, 895, 136, 136,
    136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 900, 900, 900, 900, 900, 895, 895, 895, 916,
    900, 900, 900, 951, 952, 895, 93, 214, 214, 945, 945, 214, 214, 214, 214, 214, 214, 214, 214,
    93, 93, 93, 93, 93, 900, 900, 231, 231, 900, 953, 953, 954, 955, 895, 895, 956, 957, 895, 958,
    958, 959, 397, 959, 895, 471, 959, 895, 474, 474, 895, 474, 895, 479, 479, 479, 479, 479, 479,
    479, 479, 479, 479, 479, 479, 479, 479, 900, 900, 900, 900, 900, 895, 895, 960, 900, 900, 900,
    895, 895, 961, 961, 895, 214, 945, 945, 214, 214, 945, 214, 214, 214, 214, 214, 93, 93, 93, 93,
    93, 900, 526, 526, 895, 962, 963, 461, 895, 533, 533, 895, 533, 895, 895, 964, 964, 895, 895,
    965, 965, 966, 477, 966, 895, 549, 966, 895, 552, 552, 895, 552, 895, 895, 895, 559, 559, 895,
    895, 559, 559, 559, 895, 895, 559, 559, 559, 559, 895, 895, 895, 895, 559, 900, 895, 895, 967,
    900, 900, 900, 968, 969, 895, 970, 970, 895, 970, 970, 590, 590, 971, 900, 900, 900, 598, 598,
    895, 972, 895, 973, 536, 973, 973, 607, 973, 895, 610, 610, 895, 610, 974, 975, 895, 895, 976,
    976, 977, 978, 977, 895, 624, 977, 895, 627, 627, 627, 895, 631, 631, 631, 631, 631, 631, 631,
    631, 631, 900, 895, 895, 979, 900, 900, 900, 895, 895, 980, 980, 895, 981, 981, 895, 981, 981,
    655, 655, 982, 900, 661, 661, 661, 895, 983, 984, 895, 985, 985, 986, 987, 986, 986, 674, 986,
    895, 677, 677, 895, 677, 895, 895, 988, 988, 895, 895, 989, 989, 990, 990, 990, 692, 990, 631,
    631, 631, 895, 895, 631, 631, 895, 895, 895, 895, 631, 895, 895, 991, 979, 900, 992, 993, 994,
    995, 895, 994, 996, 996, 996, 996, 900, 900, 900, 724, 724, 900, 895, 895, 997, 997, 895, 895,
    998, 998, 999, 680, 999, 999, 739, 999, 895, 742, 742, 895, 742, 1000, 1001, 895, 895, 1002,
    1002, 895, 895, 895, 753, 753, 753, 895, 1003, 1003, 895, 1003, 1004, 900, 1005, 1005, 1005,
    1005, 1006, 1005, 1007, 1007, 895, 895, 994, 994, 895, 895, 996, 996, 996, 724, 724, 724, 1008,
    1009, 895, 895, 1010, 1010, 1011, 745, 1011, 1011, 795, 1011, 895, 798, 798, 798, 895, 1000,
    1000, 895, 895, 895, 895, 753, 753, 895, 895, 1004, 895, 895, 1012, 1013, 895, 996, 996, 724,
    900, 724, 724, 900, 895, 895, 1008, 1008, 895, 895, 1014, 1014, 1015, 1015, 1015, 836, 836,
    895, 895, 753, 1016, 895, 895, 1012, 1012, 895, 996, 724, 724, 724, 895, 895, 895, 895, 1017,
    1017, 895, 895, 1016, 1016, 895, 1016, 1018, 1019, 895, 724, 900, 724, 724, 900, 895, 895, 895,
    895, 895, 895, 895, 895, 1018, 1018, 895, 900, 900, 900, 895, 895, 895, 900, 900, 900, 895,
    895, 895, 0, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
    895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
    895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
    895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
    895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
    895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
    895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
];
static mut yy_nxt: [flex_int16_t; 6281] = [
    0, 16, 17, 18, 19, 17, 20, 21, 22, 23, 24, 25, 16, 26, 27, 16, 16, 28, 29, 30, 31, 29, 29, 29,
    29, 29, 29, 29, 32, 33, 34, 16, 35, 36, 36, 36, 37, 38, 39, 39, 39, 39, 40, 41, 42, 39, 43, 44,
    45, 46, 39, 39, 39, 39, 39, 47, 16, 48, 48, 48, 48, 48, 48, 16, 16, 16, 16, 16, 16, 16, 16, 49,
    16, 16, 50, 109, 136, 50, 109, 139, 51, 118, 144, 17, 66, 67, 17, 68, 136, 69, 17, 66, 67, 17,
    68, 69, 69, 145, 140, 138, 148, 119, 69, 141, 146, 136, 52, 53, 136, 69, 70, 54, 108, 108, 149,
    168, 69, 70, 168, 55, 108, 154, 56, 57, 164, 261, 57, 169, 120, 58, 155, 171, 166, 163, 171,
    59, 71, 421, 60, 150, 151, 180, 150, 71, 83, 18, 19, 83, 84, 85, 83, 18, 19, 83, 84, 85, 193,
    124, 124, 193, 151, 124, 124, 61, 187, 62, 108, 63, 39, 188, 39, 130, 130, 130, 130, 130, 130,
    130, 130, 130, 130, 124, 131, 131, 131, 131, 131, 132, 108, 108, 186, 156, 64, 57, 156, 186,
    57, 86, 154, 58, 194, 118, 214, 86, 270, 59, 125, 176, 60, 192, 173, 173, 108, 217, 173, 173,
    190, 151, 180, 190, 224, 199, 214, 157, 158, 218, 495, 109, 159, 225, 109, 113, 227, 61, 173,
    62, 160, 63, 39, 161, 39, 195, 196, 197, 195, 237, 191, 878, 200, 192, 211, 211, 211, 211, 211,
    212, 239, 108, 171, 174, 201, 171, 64, 17, 18, 19, 17, 20, 201, 72, 108, 201, 260, 108, 201,
    201, 210, 210, 210, 210, 210, 210, 210, 210, 210, 210, 268, 108, 203, 351, 201, 116, 116, 116,
    116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 113, 227,
    878, 204, 201, 73, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 17,
    18, 19, 17, 20, 118, 72, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235,
    235, 235, 113, 227, 895, 235, 235, 235, 235, 235, 235, 235, 235, 235, 235, 247, 248, 150, 151,
    180, 150, 249, 250, 171, 108, 251, 171, 252, 253, 107, 272, 200, 73, 74, 74, 74, 74, 74, 74,
    74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 17, 18, 19, 17, 20, 76, 72, 150, 151, 180, 150,
    77, 78, 79, 124, 124, 267, 108, 124, 124, 150, 151, 180, 150, 269, 275, 108, 80, 275, 168, 271,
    274, 168, 150, 151, 180, 150, 156, 124, 194, 156, 169, 116, 116, 116, 116, 116, 116, 116, 116,
    116, 116, 108, 81, 17, 18, 19, 17, 20, 76, 72, 297, 227, 125, 237, 77, 78, 79, 349, 157, 158,
    113, 299, 108, 159, 313, 878, 247, 248, 331, 332, 80, 160, 249, 250, 161, 186, 251, 192, 252,
    895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 195, 196, 197, 195, 113, 299, 878, 81, 34,
    17, 18, 19, 17, 20, 34, 34, 87, 24, 25, 34, 88, 27, 34, 34, 89, 90, 91, 92, 90, 90, 90, 90, 90,
    90, 90, 32, 93, 34, 34, 94, 95, 95, 95, 96, 97, 98, 98, 98, 98, 99, 100, 101, 98, 102, 98, 103,
    98, 98, 98, 98, 98, 98, 73, 34, 104, 104, 104, 104, 104, 104, 105, 105, 105, 105, 105, 105,
    105, 105, 106, 105, 105, 113, 114, 173, 173, 878, 193, 173, 173, 193, 113, 227, 275, 115, 603,
    275, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 126, 173, 127, 127, 127, 127, 127, 127,
    127, 127, 127, 127, 128, 237, 108, 108, 129, 129, 129, 129, 129, 129, 185, 108, 313, 185, 174,
    185, 185, 342, 108, 349, 793, 192, 185, 349, 297, 299, 349, 108, 348, 129, 129, 129, 129, 129,
    129, 107, 108, 185, 198, 198, 198, 198, 423, 107, 198, 198, 107, 107, 198, 107, 107, 107, 135,
    135, 135, 135, 135, 135, 135, 135, 135, 135, 128, 198, 198, 107, 135, 135, 135, 135, 135, 135,
    136, 136, 136, 136, 137, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 108, 136,
    129, 129, 129, 129, 129, 129, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 136, 136,
    136, 136, 136, 136, 136, 136, 136, 136, 895, 895, 118, 300, 136, 136, 136, 136, 136, 136, 372,
    373, 843, 374, 136, 280, 280, 280, 280, 280, 280, 895, 895, 303, 303, 303, 303, 303, 304, 107,
    107, 107, 107, 107, 107, 150, 151, 152, 153, 107, 107, 107, 108, 107, 107, 287, 288, 107, 200,
    200, 422, 289, 290, 124, 108, 291, 124, 292, 128, 124, 430, 107, 107, 107, 107, 124, 129, 129,
    129, 129, 129, 129, 129, 129, 129, 129, 113, 114, 237, 124, 124, 107, 107, 107, 107, 108, 108,
    843, 115, 313, 108, 116, 116, 116, 116, 116, 116, 116, 116, 116, 116, 201, 339, 340, 352, 341,
    383, 383, 383, 201, 399, 419, 201, 399, 420, 201, 201, 276, 277, 278, 276, 276, 276, 276, 276,
    276, 276, 403, 497, 203, 437, 201, 404, 108, 428, 438, 400, 108, 162, 179, 151, 180, 179, 181,
    447, 182, 108, 448, 843, 181, 452, 182, 387, 237, 494, 204, 201, 392, 392, 392, 392, 392, 393,
    108, 389, 182, 182, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, 280,
    280, 280, 280, 280, 280, 108, 496, 108, 659, 214, 182, 113, 114, 230, 230, 230, 230, 230, 230,
    230, 230, 230, 230, 183, 113, 227, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 124, 405,
    108, 108, 405, 124, 124, 498, 124, 124, 124, 124, 697, 136, 124, 124, 230, 230, 230, 230, 230,
    230, 230, 230, 230, 230, 895, 406, 203, 124, 124, 302, 302, 302, 302, 302, 302, 302, 302, 302,
    302, 318, 318, 318, 318, 318, 318, 318, 318, 318, 318, 427, 108, 591, 206, 124, 203, 504, 592,
    207, 203, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 128, 203, 387, 237, 209, 209, 209,
    209, 209, 209, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
    203, 895, 237, 209, 209, 209, 209, 209, 209, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
    203, 895, 603, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 895, 108, 895, 237, 203, 203,
    203, 203, 203, 203, 173, 578, 399, 173, 389, 399, 173, 757, 136, 113, 227, 353, 173, 354, 354,
    354, 354, 354, 354, 203, 203, 203, 203, 203, 203, 203, 173, 173, 400, 203, 213, 213, 213, 213,
    213, 213, 213, 213, 213, 213, 128, 203, 113, 227, 213, 213, 213, 213, 213, 213, 214, 214, 214,
    214, 215, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 644, 216, 209, 209, 209,
    209, 209, 209, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 214, 214, 214, 214, 214,
    214, 214, 214, 214, 214, 895, 108, 793, 581, 214, 214, 214, 214, 214, 214, 405, 108, 503, 405,
    214, 391, 391, 391, 391, 391, 391, 391, 391, 391, 391, 128, 113, 227, 583, 203, 203, 203, 203,
    203, 203, 895, 406, 209, 209, 209, 209, 209, 209, 209, 209, 209, 209, 107, 107, 107, 107, 107,
    108, 107, 107, 737, 502, 107, 431, 432, 433, 431, 431, 431, 431, 431, 431, 431, 706, 826, 429,
    107, 107, 107, 117, 117, 117, 117, 117, 108, 117, 117, 826, 136, 117, 463, 464, 465, 463, 463,
    463, 463, 463, 463, 463, 237, 501, 136, 117, 117, 117, 121, 121, 121, 121, 121, 313, 121, 121,
    634, 603, 121, 398, 398, 398, 398, 398, 398, 398, 398, 398, 398, 605, 136, 237, 121, 121, 121,
    124, 633, 107, 123, 107, 107, 123, 389, 107, 107, 387, 237, 123, 387, 237, 467, 467, 467, 467,
    467, 467, 696, 389, 136, 826, 389, 123, 123, 107, 231, 232, 233, 231, 231, 231, 231, 231, 231,
    231, 471, 471, 471, 471, 471, 471, 471, 471, 471, 471, 472, 472, 472, 472, 472, 473, 399, 405,
    108, 399, 405, 550, 550, 550, 550, 550, 551, 108, 126, 582, 234, 234, 234, 234, 234, 234, 234,
    234, 234, 234, 128, 843, 400, 406, 234, 234, 234, 234, 234, 234, 387, 237, 478, 478, 478, 478,
    478, 478, 478, 478, 478, 478, 469, 843, 895, 237, 108, 108, 237, 234, 234, 234, 234, 234, 234,
    107, 469, 562, 567, 389, 562, 567, 646, 107, 136, 841, 107, 107, 635, 107, 107, 107, 240, 240,
    240, 240, 240, 240, 240, 240, 240, 240, 128, 563, 568, 107, 240, 240, 240, 240, 240, 240, 136,
    136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 108, 136, 234,
    234, 234, 234, 234, 234, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 136, 136, 136,
    136, 136, 136, 136, 136, 136, 136, 895, 108, 237, 722, 136, 136, 136, 136, 136, 136, 452, 584,
    453, 453, 453, 453, 453, 453, 549, 549, 549, 549, 549, 549, 549, 549, 549, 549, 108, 107, 107,
    107, 107, 107, 107, 173, 136, 107, 172, 107, 107, 172, 108, 107, 107, 641, 632, 172, 895, 108,
    585, 586, 587, 585, 585, 585, 585, 585, 585, 585, 605, 172, 172, 107, 201, 201, 201, 201, 201,
    895, 201, 201, 895, 237, 201, 387, 237, 545, 545, 545, 545, 545, 545, 895, 469, 136, 895, 469,
    201, 201, 201, 124, 639, 136, 237, 895, 124, 124, 108, 124, 124, 124, 124, 636, 895, 124, 124,
    895, 645, 895, 895, 387, 237, 895, 559, 895, 387, 237, 895, 203, 124, 124, 136, 469, 637, 387,
    237, 560, 547, 136, 895, 895, 237, 638, 895, 136, 895, 895, 571, 700, 237, 895, 640, 547, 136,
    206, 124, 279, 279, 279, 279, 279, 279, 279, 279, 279, 279, 561, 564, 108, 895, 279, 279, 279,
    279, 279, 279, 895, 573, 237, 895, 573, 565, 237, 237, 765, 505, 566, 506, 506, 506, 506, 506,
    506, 469, 547, 279, 279, 279, 279, 279, 279, 203, 895, 574, 722, 203, 281, 281, 281, 281, 281,
    281, 281, 281, 281, 281, 128, 203, 570, 737, 281, 281, 281, 281, 281, 281, 214, 214, 214, 214,
    214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 108, 216, 279, 279, 279, 279,
    279, 279, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 214, 214, 214, 214, 214, 214,
    214, 214, 214, 214, 895, 237, 672, 108, 214, 214, 214, 214, 214, 214, 895, 658, 547, 895, 599,
    599, 599, 599, 599, 600, 647, 895, 575, 895, 895, 575, 895, 826, 214, 203, 203, 203, 203, 203,
    203, 300, 895, 301, 301, 301, 301, 301, 301, 301, 301, 301, 301, 895, 576, 895, 557, 762, 763,
    557, 608, 608, 608, 608, 608, 609, 569, 237, 562, 567, 572, 562, 567, 701, 826, 136, 577, 108,
    622, 711, 108, 107, 558, 305, 305, 305, 305, 305, 305, 305, 305, 305, 305, 573, 563, 568, 573,
    305, 305, 305, 305, 305, 305, 598, 598, 598, 598, 598, 598, 598, 598, 598, 598, 575, 557, 562,
    575, 557, 562, 574, 774, 596, 305, 305, 305, 305, 305, 305, 307, 308, 309, 309, 309, 309, 309,
    309, 309, 309, 310, 576, 558, 563, 311, 311, 311, 311, 311, 311, 537, 537, 537, 537, 537, 537,
    537, 537, 537, 537, 538, 108, 539, 539, 539, 539, 539, 539, 774, 311, 311, 311, 311, 311, 311,
    237, 314, 315, 316, 314, 314, 314, 314, 314, 314, 314, 317, 727, 727, 727, 318, 318, 318, 318,
    318, 318, 607, 607, 607, 607, 607, 607, 607, 607, 607, 607, 625, 625, 625, 625, 625, 626, 756,
    774, 136, 318, 318, 318, 318, 318, 318, 319, 319, 319, 319, 319, 319, 319, 319, 319, 319, 128,
    812, 763, 774, 319, 319, 319, 319, 319, 319, 615, 616, 617, 615, 615, 615, 615, 615, 615, 615,
    107, 107, 107, 107, 387, 237, 862, 863, 773, 305, 305, 305, 305, 305, 305, 353, 547, 356, 356,
    356, 356, 356, 357, 354, 354, 354, 354, 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, 128,
    814, 113, 227, 358, 358, 358, 358, 358, 358, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556,
    567, 573, 575, 567, 573, 575, 821, 877, 863, 358, 358, 358, 358, 358, 358, 359, 359, 359, 359,
    359, 359, 359, 359, 359, 359, 771, 568, 574, 576, 359, 359, 359, 359, 359, 359, 387, 237, 620,
    620, 620, 620, 620, 620, 753, 764, 108, 136, 547, 675, 675, 675, 675, 675, 676, 358, 358, 358,
    358, 358, 358, 376, 377, 378, 376, 376, 376, 376, 376, 376, 376, 624, 624, 624, 624, 624, 624,
    624, 624, 624, 624, 666, 667, 668, 666, 666, 666, 666, 666, 666, 666, 693, 693, 693, 693, 693,
    694, 108, 108, 381, 381, 382, 383, 383, 383, 383, 383, 383, 383, 310, 387, 237, 388, 388, 388,
    388, 388, 388, 388, 388, 388, 388, 389, 184, 184, 184, 390, 390, 390, 390, 390, 390, 614, 614,
    614, 614, 614, 614, 614, 614, 614, 614, 811, 702, 704, 698, 702, 704, 698, 770, 810, 390, 390,
    390, 390, 390, 390, 237, 394, 395, 396, 394, 394, 394, 394, 394, 394, 394, 397, 703, 705, 699,
    398, 398, 398, 398, 398, 398, 603, 603, 670, 670, 670, 670, 670, 670, 761, 762, 763, 761, 605,
    605, 387, 237, 136, 809, 771, 398, 398, 398, 398, 398, 398, 895, 622, 390, 390, 390, 390, 390,
    390, 390, 390, 390, 390, 434, 434, 434, 434, 434, 434, 434, 434, 434, 434, 698, 649, 649, 698,
    434, 434, 434, 434, 434, 434, 674, 674, 674, 674, 674, 674, 674, 674, 674, 674, 237, 702, 702,
    758, 702, 702, 699, 867, 136, 434, 434, 434, 434, 434, 434, 435, 435, 435, 435, 435, 435, 435,
    435, 435, 435, 895, 237, 703, 703, 435, 435, 435, 435, 435, 435, 603, 895, 622, 387, 237, 689,
    689, 689, 689, 689, 689, 108, 672, 672, 603, 622, 136, 650, 650, 434, 434, 434, 434, 434, 434,
    452, 672, 453, 453, 453, 453, 453, 453, 453, 453, 453, 453, 452, 603, 454, 454, 454, 454, 454,
    454, 454, 454, 454, 454, 452, 737, 455, 455, 455, 455, 455, 456, 453, 453, 453, 453, 458, 458,
    458, 458, 458, 458, 458, 458, 458, 458, 310, 387, 237, 467, 467, 467, 467, 467, 467, 467, 467,
    467, 467, 389, 184, 184, 184, 466, 466, 466, 466, 466, 466, 692, 692, 692, 692, 692, 692, 692,
    692, 692, 692, 649, 649, 704, 754, 704, 704, 754, 704, 237, 466, 466, 466, 466, 466, 466, 387,
    237, 468, 468, 468, 468, 468, 468, 468, 468, 468, 468, 469, 705, 755, 705, 470, 470, 470, 470,
    470, 470, 709, 113, 227, 709, 714, 715, 716, 717, 714, 714, 714, 714, 714, 714, 136, 136, 354,
    237, 354, 470, 470, 470, 470, 470, 470, 237, 474, 475, 476, 474, 474, 474, 474, 474, 474, 474,
    477, 355, 672, 355, 478, 478, 478, 478, 478, 478, 648, 649, 649, 649, 649, 649, 649, 774, 605,
    779, 779, 779, 710, 740, 740, 740, 740, 740, 741, 478, 478, 478, 478, 478, 478, 895, 895, 470,
    470, 470, 470, 470, 470, 470, 470, 470, 470, 505, 737, 508, 508, 508, 508, 508, 509, 506, 506,
    506, 506, 434, 434, 434, 434, 434, 434, 434, 434, 434, 434, 712, 728, 113, 227, 434, 434, 434,
    434, 434, 434, 724, 724, 724, 724, 724, 724, 724, 724, 724, 724, 802, 802, 712, 712, 712, 712,
    506, 728, 506, 434, 434, 434, 434, 434, 434, 435, 435, 435, 435, 435, 435, 435, 435, 435, 435,
    712, 728, 712, 713, 435, 435, 435, 435, 435, 435, 725, 725, 725, 725, 725, 726, 727, 727, 727,
    727, 754, 774, 116, 754, 813, 116, 507, 108, 507, 434, 434, 434, 434, 434, 434, 526, 527, 528,
    526, 526, 526, 526, 526, 526, 526, 603, 755, 735, 735, 735, 735, 735, 735, 107, 107, 107, 107,
    672, 739, 739, 739, 739, 739, 739, 739, 739, 739, 739, 761, 762, 763, 761, 108, 452, 603, 453,
    453, 453, 453, 453, 453, 453, 453, 453, 453, 452, 737, 453, 453, 453, 453, 453, 453, 453, 453,
    453, 453, 533, 534, 535, 533, 533, 533, 533, 533, 533, 533, 536, 539, 774, 539, 537, 537, 537,
    537, 537, 537, 747, 748, 749, 747, 747, 747, 747, 747, 747, 747, 682, 759, 683, 683, 683, 683,
    683, 683, 136, 537, 537, 537, 537, 537, 537, 538, 682, 541, 541, 541, 541, 541, 542, 539, 539,
    539, 539, 387, 237, 545, 545, 545, 545, 545, 545, 545, 545, 545, 545, 469, 387, 237, 682, 544,
    544, 544, 544, 544, 544, 803, 803, 237, 622, 387, 237, 752, 752, 752, 752, 752, 752, 767, 622,
    682, 767, 768, 769, 770, 544, 544, 544, 544, 544, 544, 387, 237, 546, 546, 546, 546, 546, 546,
    546, 546, 546, 546, 547, 540, 680, 540, 548, 548, 548, 548, 548, 548, 767, 605, 728, 767, 768,
    769, 770, 768, 769, 770, 728, 895, 895, 895, 895, 895, 895, 532, 771, 548, 548, 548, 548, 548,
    548, 237, 552, 553, 554, 552, 552, 552, 552, 552, 552, 552, 555, 895, 895, 895, 556, 556, 556,
    556, 556, 556, 796, 796, 796, 796, 796, 797, 603, 773, 721, 720, 771, 782, 780, 754, 781, 506,
    754, 506, 793, 556, 556, 556, 556, 556, 556, 895, 719, 548, 548, 548, 548, 548, 548, 548, 548,
    548, 548, 107, 557, 755, 807, 557, 718, 807, 230, 107, 648, 230, 107, 107, 648, 107, 107, 107,
    136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 558, 648, 808, 107, 136, 136, 136, 136, 136,
    136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 108,
    136, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 596,
    597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 786, 787, 788, 786, 786, 786, 786, 786, 786,
    786, 728, 108, 729, 729, 729, 729, 729, 729, 774, 708, 775, 775, 775, 775, 775, 775, 707, 108,
    603, 895, 604, 604, 604, 604, 604, 604, 604, 604, 604, 604, 605, 793, 108, 136, 606, 606, 606,
    606, 606, 606, 746, 746, 746, 746, 746, 746, 746, 746, 746, 746, 767, 237, 682, 767, 768, 769,
    770, 682, 532, 606, 606, 606, 606, 606, 606, 610, 611, 612, 610, 610, 610, 610, 610, 610, 610,
    613, 539, 385, 539, 614, 614, 614, 614, 614, 614, 603, 603, 791, 791, 791, 791, 791, 791, 842,
    113, 227, 842, 737, 793, 856, 856, 856, 856, 771, 614, 614, 614, 614, 614, 614, 895, 660, 606,
    606, 606, 606, 606, 606, 606, 606, 606, 606, 387, 237, 620, 620, 620, 620, 620, 620, 620, 620,
    620, 620, 547, 683, 657, 683, 619, 619, 619, 619, 619, 619, 795, 795, 795, 795, 795, 795, 795,
    795, 795, 795, 656, 654, 807, 895, 895, 807, 895, 895, 653, 619, 619, 619, 619, 619, 619, 387,
    237, 621, 621, 621, 621, 621, 621, 621, 621, 621, 621, 622, 808, 895, 895, 623, 623, 623, 623,
    623, 623, 816, 817, 818, 816, 816, 816, 816, 816, 816, 816, 684, 807, 684, 819, 807, 820, 729,
    648, 729, 623, 623, 623, 623, 623, 623, 237, 627, 628, 629, 627, 627, 627, 627, 627, 627, 627,
    839, 808, 648, 839, 630, 630, 630, 630, 630, 630, 801, 801, 801, 801, 801, 801, 801, 801, 801,
    801, 837, 837, 837, 837, 837, 838, 840, 643, 642, 630, 630, 630, 630, 630, 630, 895, 136, 623,
    623, 623, 623, 623, 623, 623, 623, 623, 623, 107, 237, 802, 802, 802, 802, 802, 802, 107, 538,
    815, 107, 107, 815, 107, 107, 107, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 730, 538,
    730, 107, 136, 136, 136, 136, 136, 136, 136, 136, 631, 136, 136, 136, 136, 136, 136, 136, 136,
    136, 136, 136, 136, 136, 136, 108, 136, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
    107, 107, 107, 107, 107, 107, 648, 651, 651, 651, 651, 651, 652, 649, 649, 649, 649, 203, 683,
    538, 683, 203, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 775, 203, 775, 532, 214, 214,
    214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 655,
    214, 214, 385, 216, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
    203, 203, 661, 662, 663, 664, 661, 661, 661, 661, 661, 661, 603, 310, 833, 833, 833, 833, 833,
    833, 861, 862, 863, 861, 793, 836, 836, 836, 836, 836, 836, 836, 836, 836, 836, 861, 862, 863,
    861, 108, 596, 597, 597, 597, 597, 597, 597, 597, 597, 597, 597, 815, 815, 815, 815, 815, 815,
    815, 815, 815, 815, 815, 815, 815, 815, 815, 815, 815, 815, 815, 815, 872, 872, 872, 872, 872,
    872, 595, 108, 603, 594, 670, 670, 670, 670, 670, 670, 670, 670, 670, 670, 605, 603, 593, 671,
    671, 671, 671, 671, 671, 671, 671, 671, 671, 672, 776, 590, 776, 673, 673, 673, 673, 673, 673,
    852, 853, 854, 852, 852, 852, 852, 852, 852, 852, 839, 895, 839, 839, 895, 839, 729, 589, 729,
    673, 673, 673, 673, 673, 673, 677, 678, 679, 677, 677, 677, 677, 677, 677, 677, 680, 840, 895,
    840, 681, 681, 681, 681, 681, 681, 826, 588, 827, 827, 827, 827, 827, 827, 827, 828, 827, 828,
    858, 848, 844, 858, 844, 505, 505, 681, 681, 681, 681, 681, 681, 895, 505, 673, 673, 673, 673,
    673, 673, 673, 673, 673, 673, 682, 859, 685, 685, 685, 685, 685, 686, 683, 683, 683, 683, 387,
    237, 689, 689, 689, 689, 689, 689, 689, 689, 689, 689, 622, 845, 580, 845, 688, 688, 688, 688,
    688, 688, 821, 579, 822, 822, 822, 822, 822, 822, 864, 865, 866, 864, 864, 864, 864, 864, 864,
    864, 108, 688, 688, 688, 688, 688, 688, 387, 237, 690, 690, 690, 690, 690, 690, 690, 690, 690,
    690, 858, 108, 108, 858, 691, 691, 691, 691, 691, 691, 843, 108, 844, 844, 844, 844, 844, 844,
    108, 879, 876, 879, 858, 876, 538, 858, 859, 876, 538, 691, 691, 691, 691, 691, 691, 895, 532,
    691, 691, 691, 691, 691, 691, 691, 691, 691, 691, 107, 859, 892, 892, 892, 892, 892, 892, 107,
    385, 310, 107, 107, 310, 107, 107, 107, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 880,
    525, 880, 107, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
    136, 136, 136, 695, 136, 136, 136, 108, 136, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
    107, 107, 107, 107, 107, 107, 107, 698, 524, 878, 698, 879, 879, 879, 879, 879, 879, 523, 203,
    522, 521, 520, 203, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 699, 203, 519, 518, 214,
    214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214, 214,
    214, 214, 214, 517, 216, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
    203, 203, 203, 722, 516, 723, 723, 723, 723, 723, 723, 723, 723, 723, 723, 872, 872, 872, 872,
    872, 872, 872, 872, 872, 872, 873, 873, 873, 873, 873, 873, 873, 873, 873, 873, 515, 514, 513,
    512, 511, 510, 505, 108, 728, 505, 731, 731, 731, 731, 731, 732, 729, 729, 729, 729, 603, 424,
    735, 735, 735, 735, 735, 735, 735, 735, 735, 735, 672, 603, 500, 736, 736, 736, 736, 736, 736,
    736, 736, 736, 736, 737, 499, 493, 492, 738, 738, 738, 738, 738, 738, 874, 874, 874, 874, 874,
    875, 872, 872, 872, 872, 867, 491, 868, 868, 868, 868, 868, 868, 490, 738, 738, 738, 738, 738,
    738, 742, 743, 744, 742, 742, 742, 742, 742, 742, 742, 745, 489, 488, 487, 746, 746, 746, 746,
    746, 746, 486, 485, 484, 483, 108, 872, 872, 872, 872, 872, 872, 872, 872, 872, 872, 482, 481,
    480, 479, 746, 746, 746, 746, 746, 746, 895, 461, 738, 738, 738, 738, 738, 738, 738, 738, 738,
    738, 387, 237, 752, 752, 752, 752, 752, 752, 752, 752, 752, 752, 774, 385, 777, 777, 777, 777,
    777, 778, 779, 779, 779, 779, 783, 784, 785, 783, 783, 783, 783, 783, 783, 783, 872, 872, 872,
    872, 872, 872, 872, 872, 872, 872, 886, 887, 888, 886, 886, 886, 886, 886, 886, 886, 310, 457,
    310, 134, 451, 450, 449, 108, 722, 446, 723, 723, 723, 723, 723, 723, 723, 723, 723, 723, 892,
    892, 892, 892, 892, 892, 892, 892, 892, 892, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886,
    445, 444, 443, 442, 441, 440, 439, 108, 603, 436, 791, 791, 791, 791, 791, 791, 791, 791, 791,
    791, 737, 603, 353, 792, 792, 792, 792, 792, 792, 792, 792, 792, 792, 793, 353, 353, 424, 794,
    794, 794, 794, 794, 794, 893, 893, 893, 893, 893, 894, 892, 892, 892, 892, 889, 889, 889, 889,
    889, 889, 426, 424, 425, 794, 794, 794, 794, 794, 794, 798, 799, 800, 798, 798, 798, 798, 798,
    798, 798, 424, 418, 417, 416, 801, 801, 801, 801, 801, 801, 415, 414, 108, 892, 892, 892, 892,
    892, 892, 892, 892, 892, 892, 413, 412, 411, 410, 409, 408, 801, 801, 801, 801, 801, 801, 895,
    407, 794, 794, 794, 794, 794, 794, 794, 794, 794, 794, 237, 804, 804, 804, 804, 804, 805, 802,
    802, 802, 802, 107, 402, 401, 128, 310, 385, 310, 134, 107, 375, 371, 107, 107, 370, 107, 107,
    107, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 369, 368, 367, 107, 136, 136, 136, 136,
    136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
    108, 136, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107, 107,
    766, 766, 766, 766, 766, 366, 766, 766, 365, 364, 766, 363, 362, 361, 360, 207, 353, 353, 350,
    347, 346, 345, 344, 343, 766, 766, 766, 772, 772, 772, 772, 772, 338, 772, 772, 337, 336, 772,
    335, 334, 333, 330, 329, 328, 327, 326, 325, 324, 323, 322, 321, 772, 772, 772, 821, 320, 822,
    822, 822, 822, 822, 822, 822, 822, 822, 822, 821, 134, 823, 823, 823, 823, 823, 823, 823, 823,
    823, 823, 821, 126, 824, 824, 824, 824, 824, 825, 822, 822, 822, 822, 826, 296, 829, 829, 829,
    829, 829, 830, 827, 827, 827, 827, 603, 295, 833, 833, 833, 833, 833, 833, 833, 833, 833, 833,
    793, 603, 294, 834, 834, 834, 834, 834, 834, 834, 834, 834, 834, 293, 286, 285, 284, 835, 835,
    835, 835, 835, 835, 283, 282, 895, 204, 196, 191, 192, 186, 186, 151, 178, 273, 266, 265, 264,
    263, 262, 259, 258, 835, 835, 835, 835, 835, 835, 895, 257, 835, 835, 835, 835, 835, 835, 835,
    835, 835, 835, 843, 256, 846, 846, 846, 846, 846, 847, 844, 844, 844, 844, 107, 255, 849, 850,
    851, 849, 849, 849, 849, 849, 849, 849, 821, 254, 822, 822, 822, 822, 822, 822, 822, 822, 822,
    822, 821, 246, 822, 822, 822, 822, 822, 822, 822, 822, 822, 822, 603, 245, 857, 857, 857, 857,
    857, 857, 857, 857, 857, 857, 867, 244, 868, 868, 868, 868, 868, 868, 868, 868, 868, 868, 867,
    243, 869, 869, 869, 869, 869, 869, 869, 869, 869, 869, 867, 242, 870, 870, 870, 870, 870, 871,
    868, 868, 868, 868, 878, 241, 881, 881, 881, 881, 881, 882, 879, 879, 879, 879, 107, 134, 883,
    884, 885, 883, 883, 883, 883, 883, 883, 883, 867, 107, 868, 868, 868, 868, 868, 868, 868, 868,
    868, 868, 867, 134, 868, 868, 868, 868, 868, 868, 868, 868, 868, 868, 889, 889, 889, 889, 889,
    889, 889, 889, 889, 889, 206, 122, 229, 120, 113, 111, 108, 223, 222, 221, 220, 219, 214, 192,
    186, 178, 110, 144, 175, 141, 170, 167, 165, 147, 146, 143, 142, 108, 883, 883, 883, 883, 883,
    883, 883, 883, 883, 883, 136, 134, 122, 111, 110, 108, 895, 895, 895, 895, 895, 895, 895, 895,
    895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 108, 890, 890, 890, 890, 890,
    891, 889, 889, 889, 889, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
    895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 108, 889, 889, 889, 889, 889,
    889, 889, 889, 889, 889, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
    895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 108, 65, 65, 65, 65, 65, 65,
    65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 65, 34, 34, 34, 34, 34, 34, 34, 34, 34,
    34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
    75, 75, 75, 75, 75, 75, 75, 75, 75, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82,
    82, 82, 82, 82, 82, 82, 107, 895, 895, 895, 895, 895, 895, 107, 895, 107, 107, 107, 107, 895,
    895, 107, 107, 107, 107, 107, 107, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112, 112,
    112, 112, 112, 112, 112, 112, 112, 112, 112, 117, 895, 895, 895, 895, 117, 895, 117, 895, 117,
    117, 117, 117, 117, 895, 117, 117, 117, 117, 117, 117, 121, 895, 895, 895, 895, 895, 895, 121,
    895, 121, 121, 121, 121, 895, 895, 121, 121, 121, 121, 121, 121, 123, 895, 895, 123, 123, 895,
    123, 123, 895, 123, 123, 123, 123, 895, 895, 123, 123, 123, 123, 123, 123, 133, 133, 895, 133,
    895, 895, 895, 133, 172, 895, 895, 172, 172, 895, 172, 172, 895, 172, 172, 172, 172, 895, 895,
    172, 172, 172, 172, 172, 172, 177, 895, 895, 177, 177, 895, 177, 177, 895, 177, 177, 177, 177,
    895, 177, 177, 177, 895, 177, 177, 177, 185, 895, 895, 185, 895, 895, 185, 185, 895, 185, 185,
    185, 185, 185, 895, 185, 185, 185, 185, 185, 185, 189, 189, 189, 189, 189, 189, 189, 189, 189,
    189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 191, 191, 895, 191, 895, 191, 191,
    191, 191, 191, 191, 191, 191, 191, 191, 191, 191, 191, 191, 191, 191, 198, 895, 895, 895, 895,
    198, 895, 198, 895, 198, 198, 198, 198, 198, 895, 198, 198, 198, 198, 198, 198, 202, 895, 895,
    895, 895, 895, 895, 202, 895, 202, 202, 202, 202, 895, 202, 202, 202, 202, 202, 202, 202, 205,
    895, 895, 205, 205, 895, 205, 205, 895, 205, 205, 205, 205, 895, 205, 205, 205, 205, 205, 205,
    205, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
    226, 226, 226, 228, 228, 895, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228, 228,
    228, 228, 228, 228, 228, 117, 895, 895, 895, 895, 895, 895, 117, 895, 117, 117, 117, 117, 895,
    895, 117, 117, 117, 117, 117, 117, 121, 895, 895, 895, 895, 895, 895, 121, 895, 121, 121, 121,
    121, 895, 895, 121, 121, 121, 121, 121, 121, 123, 895, 895, 123, 123, 895, 123, 123, 895, 123,
    123, 123, 123, 895, 895, 123, 123, 123, 123, 123, 123, 124, 895, 895, 124, 124, 895, 124, 124,
    895, 124, 124, 124, 124, 895, 895, 124, 124, 124, 124, 124, 124, 133, 133, 895, 133, 895, 895,
    895, 133, 236, 236, 895, 236, 895, 895, 895, 236, 238, 238, 238, 895, 238, 895, 895, 895, 238,
    172, 895, 895, 172, 172, 895, 172, 172, 895, 172, 172, 172, 172, 895, 895, 172, 172, 172, 172,
    172, 172, 173, 895, 895, 173, 173, 895, 173, 173, 895, 173, 173, 173, 173, 895, 895, 173, 173,
    173, 173, 173, 173, 177, 895, 895, 177, 177, 895, 177, 177, 895, 177, 177, 177, 177, 895, 177,
    177, 177, 895, 177, 177, 177, 185, 895, 895, 185, 895, 895, 185, 185, 895, 185, 185, 185, 185,
    185, 895, 185, 185, 185, 185, 185, 185, 191, 191, 895, 191, 895, 191, 191, 191, 191, 191, 191,
    191, 191, 191, 191, 191, 191, 191, 191, 191, 191, 201, 895, 895, 895, 895, 895, 895, 201, 895,
    201, 201, 201, 201, 895, 895, 201, 201, 201, 201, 201, 201, 202, 895, 895, 895, 895, 895, 895,
    202, 895, 202, 202, 202, 202, 895, 202, 202, 202, 202, 202, 202, 202, 205, 895, 895, 205, 205,
    895, 205, 205, 895, 205, 205, 205, 205, 895, 205, 205, 205, 205, 205, 205, 205, 216, 895, 895,
    216, 216, 895, 216, 298, 298, 298, 298, 298, 298, 298, 298, 298, 298, 298, 298, 298, 298, 298,
    298, 298, 298, 298, 298, 298, 306, 306, 895, 306, 895, 895, 895, 306, 312, 312, 312, 895, 312,
    895, 895, 895, 312, 379, 379, 895, 379, 895, 895, 895, 379, 380, 380, 895, 380, 895, 895, 895,
    380, 384, 384, 895, 384, 895, 895, 895, 384, 386, 386, 386, 895, 386, 895, 895, 895, 386, 216,
    895, 895, 216, 216, 895, 216, 457, 457, 895, 457, 895, 895, 895, 457, 459, 459, 895, 459, 895,
    895, 895, 459, 460, 460, 895, 460, 895, 895, 895, 460, 462, 462, 462, 895, 462, 895, 895, 895,
    462, 466, 466, 466, 466, 895, 466, 895, 895, 895, 466, 529, 529, 895, 529, 895, 895, 895, 529,
    530, 530, 895, 530, 895, 895, 895, 530, 531, 531, 895, 531, 895, 895, 895, 531, 543, 543, 543,
    895, 543, 895, 895, 895, 543, 544, 544, 544, 544, 895, 544, 895, 895, 895, 544, 226, 226, 226,
    226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 601,
    601, 895, 601, 895, 895, 895, 601, 602, 602, 895, 602, 895, 895, 895, 602, 618, 618, 618, 895,
    618, 895, 895, 895, 618, 619, 619, 619, 619, 895, 619, 895, 895, 895, 619, 226, 226, 226, 226,
    226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 216, 895,
    895, 216, 216, 895, 216, 203, 895, 895, 895, 203, 203, 895, 203, 203, 203, 895, 895, 203, 203,
    665, 665, 895, 665, 895, 895, 895, 665, 669, 895, 669, 669, 895, 669, 895, 895, 895, 669, 687,
    687, 687, 895, 687, 895, 895, 895, 687, 688, 688, 688, 688, 895, 688, 895, 895, 895, 688, 630,
    630, 895, 895, 630, 895, 895, 895, 630, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226,
    226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 216, 895, 895, 216, 216, 895, 216, 203, 895,
    895, 895, 203, 203, 895, 203, 203, 203, 895, 895, 203, 203, 733, 733, 895, 733, 895, 895, 895,
    733, 734, 895, 734, 734, 895, 734, 895, 895, 895, 734, 681, 681, 895, 681, 895, 895, 895, 681,
    750, 750, 750, 895, 750, 895, 895, 895, 750, 751, 751, 751, 895, 895, 751, 895, 895, 895, 751,
    760, 760, 760, 760, 760, 760, 760, 760, 760, 760, 760, 760, 760, 760, 760, 760, 760, 760, 760,
    760, 760, 766, 766, 895, 766, 766, 766, 895, 766, 895, 766, 766, 766, 766, 895, 895, 766, 766,
    766, 766, 766, 766, 772, 772, 895, 772, 772, 772, 895, 772, 895, 772, 772, 772, 772, 895, 895,
    772, 772, 772, 772, 772, 772, 216, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 216, 216,
    895, 216, 216, 895, 216, 789, 789, 895, 789, 895, 895, 895, 789, 790, 895, 790, 790, 895, 790,
    895, 895, 895, 790, 806, 806, 895, 895, 806, 895, 895, 895, 806, 760, 760, 760, 760, 760, 760,
    760, 760, 760, 760, 760, 760, 760, 760, 760, 760, 760, 760, 760, 760, 760, 226, 226, 226, 226,
    226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 226, 766, 895,
    895, 895, 895, 895, 895, 766, 895, 766, 766, 766, 766, 895, 895, 766, 766, 766, 766, 766, 766,
    772, 895, 895, 895, 895, 895, 895, 772, 895, 772, 772, 772, 772, 895, 895, 772, 772, 772, 772,
    772, 772, 831, 831, 895, 831, 895, 895, 895, 831, 832, 895, 832, 832, 895, 832, 895, 895, 895,
    832, 855, 855, 895, 855, 895, 895, 895, 855, 856, 895, 856, 895, 895, 856, 895, 895, 895, 856,
    860, 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, 860, 860,
    860, 860, 15, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
    895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
    895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
    895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
];
static mut yy_chk: [flex_int16_t; 6281] = [
    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 17, 38, 2, 17, 38, 2, 23, 43, 5, 5, 5, 5, 5, 37, 5, 6, 6, 6,
    6, 6, 5, 6, 43, 40, 37, 46, 23, 6, 40, 55, 53, 2, 2, 52, 5, 5, 2, 49, 889, 46, 57, 6, 6, 57, 2,
    155, 49, 2, 3, 53, 155, 3, 57, 23, 3, 49, 59, 55, 52, 59, 3, 5, 340, 3, 73, 73, 73, 73, 6, 11,
    11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 83, 28, 28, 83, 152, 28, 28, 3, 77, 3, 340, 3, 3,
    79, 3, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 28, 31, 31, 31, 31, 31, 31, 165, 64, 77, 50, 3,
    4, 50, 79, 4, 11, 64, 4, 84, 87, 96, 12, 165, 4, 28, 64, 4, 83, 60, 60, 152, 96, 60, 60, 81,
    81, 81, 81, 106, 87, 97, 50, 50, 97, 420, 109, 50, 106, 109, 112, 112, 4, 60, 4, 50, 4, 4, 50,
    4, 86, 86, 86, 86, 134, 86, 881, 87, 84, 92, 92, 92, 92, 92, 92, 134, 420, 169, 60, 88, 169, 4,
    7, 7, 7, 7, 7, 88, 7, 154, 88, 154, 163, 88, 88, 91, 91, 91, 91, 91, 91, 91, 91, 91, 91, 163,
    271, 88, 271, 88, 115, 115, 115, 115, 115, 115, 115, 115, 115, 115, 116, 116, 116, 116, 116,
    116, 116, 116, 116, 116, 226, 226, 880, 88, 88, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
    7, 7, 7, 8, 8, 8, 8, 8, 119, 8, 130, 130, 130, 130, 130, 130, 130, 130, 130, 130, 132, 132,
    132, 132, 132, 132, 162, 162, 119, 131, 131, 131, 131, 131, 131, 131, 131, 131, 131, 143, 143,
    150, 150, 150, 150, 143, 143, 171, 167, 143, 171, 143, 143, 164, 167, 119, 8, 8, 8, 8, 8, 8, 8,
    8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 179, 179, 179, 179, 9, 9, 9, 123, 123,
    162, 166, 123, 123, 153, 153, 153, 153, 164, 196, 176, 9, 196, 168, 166, 176, 168, 190, 190,
    190, 190, 156, 123, 194, 156, 168, 170, 170, 170, 170, 170, 170, 170, 170, 170, 170, 351, 9,
    10, 10, 10, 10, 10, 10, 10, 227, 227, 123, 238, 10, 10, 10, 351, 156, 156, 228, 228, 153, 156,
    238, 879, 175, 175, 253, 253, 10, 156, 175, 175, 156, 190, 175, 194, 175, 183, 183, 183, 183,
    183, 183, 183, 183, 183, 183, 195, 195, 195, 195, 298, 298, 865, 10, 13, 13, 13, 13, 13, 13,
    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
    13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 22, 22, 172, 172,
    864, 193, 172, 172, 193, 267, 267, 275, 22, 857, 275, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
    29, 172, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 312, 270, 261, 29, 29, 29, 29, 29, 29,
    186, 272, 312, 186, 172, 186, 186, 261, 268, 270, 855, 193, 186, 268, 299, 299, 272, 29, 267,
    29, 29, 29, 29, 29, 29, 35, 342, 186, 200, 200, 200, 200, 342, 35, 200, 200, 35, 35, 200, 35,
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 200, 200, 35, 35, 35, 35, 35, 35, 35, 35,
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35,
    35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 198,
    199, 301, 39, 39, 39, 39, 39, 39, 295, 295, 846, 295, 39, 212, 212, 212, 212, 212, 212, 198,
    199, 233, 233, 233, 233, 233, 233, 39, 39, 39, 39, 39, 39, 47, 47, 47, 47, 47, 47, 47, 301, 47,
    47, 221, 221, 47, 198, 199, 341, 221, 221, 206, 352, 221, 206, 221, 305, 206, 352, 47, 47, 47,
    48, 206, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 51, 51, 386, 206, 206, 304, 304, 304, 304,
    305, 341, 845, 51, 386, 274, 51, 51, 51, 51, 51, 51, 51, 51, 51, 51, 202, 260, 260, 274, 260,
    309, 309, 309, 202, 320, 339, 202, 320, 339, 202, 202, 207, 207, 207, 207, 207, 207, 207, 207,
    207, 207, 323, 422, 202, 362, 202, 323, 349, 349, 362, 320, 260, 51, 71, 71, 71, 71, 71, 372,
    71, 339, 372, 844, 71, 453, 71, 388, 388, 419, 202, 202, 316, 316, 316, 316, 316, 316, 422,
    388, 71, 71, 210, 210, 210, 210, 210, 210, 210, 210, 210, 210, 211, 211, 211, 211, 211, 211,
    211, 211, 211, 211, 419, 421, 453, 594, 594, 71, 72, 72, 229, 229, 229, 229, 229, 229, 229,
    229, 229, 229, 72, 348, 348, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 89, 324, 423, 421, 324,
    89, 89, 423, 89, 89, 89, 89, 633, 633, 89, 89, 230, 230, 230, 230, 230, 230, 230, 230, 230,
    230, 835, 324, 89, 89, 89, 232, 232, 232, 232, 232, 232, 232, 232, 232, 232, 313, 313, 313,
    313, 313, 313, 313, 313, 313, 313, 348, 430, 515, 89, 89, 90, 430, 515, 90, 90, 90, 90, 90, 90,
    90, 90, 90, 90, 90, 90, 90, 90, 690, 690, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90,
    90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 691, 691, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90,
    90, 90, 90, 90, 90, 90, 93, 834, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 93, 498, 390, 390, 93,
    93, 93, 93, 93, 93, 273, 498, 360, 273, 390, 360, 273, 700, 700, 581, 581, 357, 273, 357, 357,
    357, 357, 357, 357, 93, 93, 93, 93, 93, 93, 94, 273, 273, 360, 94, 94, 94, 94, 94, 94, 94, 94,
    94, 94, 94, 94, 94, 501, 501, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
    94, 94, 94, 94, 94, 94, 94, 581, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
    94, 94, 94, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 98, 429, 832, 501, 98, 98, 98, 98, 98, 98,
    363, 503, 429, 363, 98, 315, 315, 315, 315, 315, 315, 315, 315, 315, 315, 350, 427, 427, 503,
    98, 98, 98, 98, 98, 98, 104, 363, 104, 104, 104, 104, 104, 104, 104, 104, 104, 104, 108, 108,
    108, 108, 108, 350, 108, 108, 831, 428, 108, 353, 353, 353, 353, 353, 353, 353, 353, 353, 353,
    640, 829, 350, 108, 108, 108, 120, 120, 120, 120, 120, 428, 120, 120, 828, 640, 120, 387, 387,
    387, 387, 387, 387, 387, 387, 387, 387, 462, 427, 564, 120, 120, 120, 122, 122, 122, 122, 122,
    462, 122, 122, 564, 604, 122, 389, 389, 389, 389, 389, 389, 389, 389, 389, 389, 604, 561, 466,
    122, 122, 122, 125, 561, 125, 125, 125, 125, 125, 466, 125, 125, 467, 467, 125, 393, 393, 393,
    393, 393, 393, 393, 393, 632, 467, 632, 827, 393, 125, 125, 125, 126, 126, 126, 126, 126, 126,
    126, 126, 126, 126, 395, 395, 395, 395, 395, 395, 395, 395, 395, 395, 396, 396, 396, 396, 396,
    396, 399, 405, 502, 399, 405, 476, 476, 476, 476, 476, 476, 126, 127, 502, 127, 127, 127, 127,
    127, 127, 127, 127, 127, 127, 127, 817, 399, 405, 127, 127, 127, 127, 127, 127, 468, 468, 469,
    469, 469, 469, 469, 469, 469, 469, 469, 469, 468, 816, 470, 470, 583, 127, 543, 127, 127, 127,
    127, 127, 127, 135, 470, 483, 486, 543, 483, 486, 583, 135, 565, 810, 135, 135, 565, 135, 135,
    135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 483, 486, 135, 135, 135, 135, 135,
    135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
    135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135, 135,
    136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, 504, 806, 723, 136, 136, 136, 136, 136,
    136, 456, 504, 456, 456, 456, 456, 456, 456, 475, 475, 475, 475, 475, 475, 475, 475, 475, 475,
    578, 136, 136, 136, 136, 136, 136, 174, 560, 174, 174, 174, 174, 174, 723, 174, 174, 578, 560,
    174, 606, 456, 505, 505, 505, 505, 505, 505, 505, 505, 505, 505, 606, 174, 174, 174, 204, 204,
    204, 204, 204, 480, 204, 204, 480, 544, 204, 473, 473, 473, 473, 473, 473, 473, 473, 481, 544,
    571, 481, 473, 204, 204, 204, 205, 571, 566, 804, 480, 205, 205, 582, 205, 205, 205, 205, 566,
    489, 205, 205, 489, 582, 481, 482, 545, 545, 482, 480, 484, 546, 546, 484, 205, 205, 205, 570,
    545, 569, 752, 752, 481, 546, 569, 489, 548, 548, 570, 485, 572, 482, 485, 489, 635, 803, 484,
    572, 548, 635, 205, 205, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 482, 484, 711, 485,
    208, 208, 208, 208, 208, 208, 488, 491, 802, 488, 491, 485, 618, 619, 711, 509, 485, 509, 509,
    509, 509, 509, 509, 618, 619, 208, 208, 208, 208, 208, 208, 213, 488, 491, 727, 213, 213, 213,
    213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 488, 790, 213, 213, 213, 213, 213, 213, 213,
    213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 727, 213, 213,
    213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 213, 214, 214, 214,
    214, 214, 214, 214, 214, 214, 214, 214, 687, 789, 584, 214, 214, 214, 214, 214, 214, 487, 593,
    687, 487, 528, 528, 528, 528, 528, 528, 584, 490, 492, 493, 490, 492, 493, 787, 593, 214, 214,
    214, 214, 214, 214, 231, 487, 231, 231, 231, 231, 231, 231, 231, 231, 231, 231, 490, 492, 493,
    510, 760, 760, 510, 535, 535, 535, 535, 535, 535, 487, 688, 513, 516, 490, 513, 516, 636, 786,
    636, 493, 645, 688, 645, 231, 234, 510, 234, 234, 234, 234, 234, 234, 234, 234, 234, 234, 519,
    513, 516, 519, 234, 234, 234, 234, 234, 234, 527, 527, 527, 527, 527, 527, 527, 527, 527, 527,
    520, 557, 562, 520, 557, 562, 519, 779, 597, 234, 234, 234, 234, 234, 234, 237, 237, 237, 237,
    237, 237, 237, 237, 237, 237, 237, 520, 557, 562, 237, 237, 237, 237, 237, 237, 532, 532, 532,
    532, 532, 532, 532, 532, 532, 532, 542, 597, 542, 542, 542, 542, 542, 542, 777, 237, 237, 237,
    237, 237, 237, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 239, 664, 664, 664, 239,
    239, 239, 239, 239, 239, 534, 534, 534, 534, 534, 534, 534, 534, 534, 534, 554, 554, 554, 554,
    554, 554, 697, 776, 697, 239, 239, 239, 239, 239, 239, 240, 240, 240, 240, 240, 240, 240, 240,
    240, 240, 240, 763, 763, 775, 240, 240, 240, 240, 240, 240, 538, 538, 538, 538, 538, 538, 538,
    538, 538, 538, 600, 600, 600, 600, 620, 620, 860, 860, 772, 240, 240, 240, 240, 240, 240, 278,
    620, 278, 278, 278, 278, 278, 278, 278, 278, 278, 278, 279, 279, 279, 279, 279, 279, 279, 279,
    279, 279, 279, 770, 710, 710, 279, 279, 279, 279, 279, 279, 547, 547, 547, 547, 547, 547, 547,
    547, 547, 547, 567, 573, 575, 567, 573, 575, 822, 863, 863, 279, 279, 279, 279, 279, 279, 281,
    281, 281, 281, 281, 281, 281, 281, 281, 281, 766, 567, 573, 575, 281, 281, 281, 281, 281, 281,
    551, 551, 551, 551, 551, 551, 551, 551, 695, 710, 822, 695, 551, 612, 612, 612, 612, 612, 612,
    281, 281, 281, 281, 281, 281, 300, 300, 300, 300, 300, 300, 300, 300, 300, 300, 553, 553, 553,
    553, 553, 553, 553, 553, 553, 553, 603, 603, 603, 603, 603, 603, 603, 603, 603, 603, 629, 629,
    629, 629, 629, 629, 765, 300, 308, 308, 308, 308, 308, 308, 308, 308, 308, 308, 308, 314, 314,
    314, 314, 314, 314, 314, 314, 314, 314, 314, 314, 314, 909, 909, 909, 314, 314, 314, 314, 314,
    314, 605, 605, 605, 605, 605, 605, 605, 605, 605, 605, 759, 658, 659, 634, 658, 659, 634, 769,
    758, 314, 314, 314, 314, 314, 314, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317, 317,
    658, 659, 634, 317, 317, 317, 317, 317, 317, 609, 670, 609, 609, 609, 609, 609, 609, 709, 709,
    709, 709, 609, 670, 621, 621, 634, 757, 769, 317, 317, 317, 317, 317, 317, 318, 621, 318, 318,
    318, 318, 318, 318, 318, 318, 318, 318, 358, 358, 358, 358, 358, 358, 358, 358, 358, 358, 698,
    968, 968, 698, 358, 358, 358, 358, 358, 358, 611, 611, 611, 611, 611, 611, 611, 611, 611, 611,
    751, 702, 637, 701, 702, 637, 698, 868, 701, 358, 358, 358, 358, 358, 358, 359, 359, 359, 359,
    359, 359, 359, 359, 359, 359, 623, 623, 702, 637, 359, 359, 359, 359, 359, 359, 671, 673, 623,
    626, 626, 626, 626, 626, 626, 626, 626, 868, 671, 673, 735, 626, 637, 969, 969, 359, 359, 359,
    359, 359, 359, 376, 735, 376, 376, 376, 376, 376, 376, 376, 376, 376, 376, 377, 736, 377, 377,
    377, 377, 377, 377, 377, 377, 377, 377, 378, 736, 378, 378, 378, 378, 378, 378, 378, 378, 378,
    378, 381, 381, 381, 381, 381, 381, 381, 381, 381, 381, 381, 391, 391, 391, 391, 391, 391, 391,
    391, 391, 391, 391, 391, 391, 929, 929, 929, 391, 391, 391, 391, 391, 391, 628, 628, 628, 628,
    628, 628, 628, 628, 628, 628, 980, 980, 638, 696, 704, 638, 696, 704, 748, 391, 391, 391, 391,
    391, 391, 394, 394, 394, 394, 394, 394, 394, 394, 394, 394, 394, 394, 394, 638, 696, 704, 394,
    394, 394, 394, 394, 394, 644, 644, 644, 644, 648, 648, 648, 648, 648, 648, 648, 648, 648, 648,
    638, 696, 939, 747, 939, 394, 394, 394, 394, 394, 394, 397, 397, 397, 397, 397, 397, 397, 397,
    397, 397, 397, 397, 940, 734, 940, 397, 397, 397, 397, 397, 397, 652, 652, 652, 652, 652, 652,
    652, 717, 733, 717, 717, 717, 644, 679, 679, 679, 679, 679, 679, 397, 397, 397, 397, 397, 397,
    398, 738, 398, 398, 398, 398, 398, 398, 398, 398, 398, 398, 433, 738, 433, 433, 433, 433, 433,
    433, 433, 433, 433, 433, 434, 434, 434, 434, 434, 434, 434, 434, 434, 434, 708, 731, 764, 764,
    434, 434, 434, 434, 434, 434, 662, 662, 662, 662, 662, 662, 662, 662, 662, 662, 1000, 1000,
    708, 646, 708, 708, 951, 730, 951, 434, 434, 434, 434, 434, 434, 435, 435, 435, 435, 435, 435,
    435, 435, 435, 435, 646, 729, 646, 646, 435, 435, 435, 435, 435, 435, 663, 663, 663, 663, 663,
    663, 663, 663, 663, 663, 718, 715, 906, 718, 764, 906, 952, 646, 952, 435, 435, 435, 435, 435,
    435, 452, 452, 452, 452, 452, 452, 452, 452, 452, 452, 676, 718, 676, 676, 676, 676, 676, 676,
    726, 726, 726, 726, 676, 678, 678, 678, 678, 678, 678, 678, 678, 678, 678, 761, 761, 761, 761,
    452, 454, 791, 454, 454, 454, 454, 454, 454, 454, 454, 454, 454, 455, 791, 455, 455, 455, 455,
    455, 455, 455, 455, 455, 455, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 461, 956, 714,
    956, 461, 461, 461, 461, 461, 461, 682, 682, 682, 682, 682, 682, 682, 682, 682, 682, 686, 707,
    686, 686, 686, 686, 686, 686, 706, 461, 461, 461, 461, 461, 461, 465, 685, 465, 465, 465, 465,
    465, 465, 465, 465, 465, 465, 471, 471, 471, 471, 471, 471, 471, 471, 471, 471, 471, 471, 471,
    689, 689, 684, 471, 471, 471, 471, 471, 471, 1001, 1001, 750, 689, 694, 694, 694, 694, 694,
    694, 694, 694, 712, 750, 683, 712, 712, 712, 712, 471, 471, 471, 471, 471, 471, 474, 474, 474,
    474, 474, 474, 474, 474, 474, 474, 474, 474, 474, 957, 672, 957, 474, 474, 474, 474, 474, 474,
    713, 669, 667, 713, 713, 713, 713, 768, 768, 768, 666, 719, 720, 721, 719, 720, 721, 665, 712,
    474, 474, 474, 474, 474, 474, 477, 477, 477, 477, 477, 477, 477, 477, 477, 477, 477, 477, 719,
    720, 721, 477, 477, 477, 477, 477, 477, 744, 744, 744, 744, 744, 744, 792, 713, 657, 656, 768,
    721, 719, 754, 720, 961, 754, 961, 792, 477, 477, 477, 477, 477, 477, 478, 654, 478, 478, 478,
    478, 478, 478, 478, 478, 478, 478, 479, 479, 754, 756, 479, 653, 756, 919, 479, 651, 919, 479,
    479, 650, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 649, 756, 479,
    479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479,
    479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479, 479,
    479, 479, 479, 479, 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, 526, 728, 728, 728, 728,
    728, 728, 728, 728, 728, 728, 732, 647, 732, 732, 732, 732, 732, 732, 778, 643, 778, 778, 778,
    778, 778, 778, 642, 526, 533, 794, 533, 533, 533, 533, 533, 533, 533, 533, 533, 533, 533, 794,
    641, 639, 533, 533, 533, 533, 533, 533, 737, 737, 737, 737, 737, 737, 737, 737, 737, 737, 767,
    622, 616, 767, 767, 767, 767, 615, 602, 533, 533, 533, 533, 533, 533, 536, 536, 536, 536, 536,
    536, 536, 536, 536, 536, 536, 964, 601, 964, 536, 536, 536, 536, 536, 536, 741, 833, 741, 741,
    741, 741, 741, 741, 813, 813, 813, 813, 741, 833, 838, 838, 838, 838, 767, 536, 536, 536, 536,
    536, 536, 537, 595, 537, 537, 537, 537, 537, 537, 537, 537, 537, 537, 549, 549, 549, 549, 549,
    549, 549, 549, 549, 549, 549, 549, 549, 974, 592, 974, 549, 549, 549, 549, 549, 549, 743, 743,
    743, 743, 743, 743, 743, 743, 743, 743, 591, 589, 780, 781, 782, 780, 781, 782, 588, 549, 549,
    549, 549, 549, 549, 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, 552, 780, 781,
    782, 552, 552, 552, 552, 552, 552, 774, 774, 774, 774, 774, 774, 774, 774, 774, 774, 975, 807,
    975, 781, 807, 782, 983, 586, 983, 552, 552, 552, 552, 552, 552, 555, 555, 555, 555, 555, 555,
    555, 555, 555, 555, 555, 809, 807, 585, 809, 555, 555, 555, 555, 555, 555, 793, 793, 793, 793,
    793, 793, 793, 793, 793, 793, 800, 800, 800, 800, 800, 800, 809, 580, 579, 555, 555, 555, 555,
    555, 555, 556, 577, 556, 556, 556, 556, 556, 556, 556, 556, 556, 556, 559, 805, 805, 805, 805,
    805, 805, 805, 559, 541, 1006, 559, 559, 1006, 559, 559, 559, 559, 559, 559, 559, 559, 559,
    559, 559, 559, 559, 984, 540, 984, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559,
    559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559,
    559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 559, 587, 587, 587, 587, 587, 587, 587,
    587, 587, 587, 587, 590, 988, 539, 988, 590, 590, 590, 590, 590, 590, 590, 590, 590, 590, 590,
    994, 590, 994, 531, 590, 590, 590, 590, 590, 590, 590, 590, 590, 590, 590, 590, 590, 590, 590,
    590, 590, 590, 590, 590, 590, 590, 590, 530, 590, 590, 590, 590, 590, 590, 590, 590, 590, 590,
    590, 590, 590, 590, 590, 590, 590, 590, 596, 596, 596, 596, 596, 596, 596, 596, 596, 596, 797,
    529, 797, 797, 797, 797, 797, 797, 842, 842, 842, 842, 797, 799, 799, 799, 799, 799, 799, 799,
    799, 799, 799, 861, 861, 861, 861, 596, 598, 598, 598, 598, 598, 598, 598, 598, 598, 598, 598,
    814, 814, 814, 814, 814, 814, 814, 814, 814, 814, 815, 815, 815, 815, 815, 815, 815, 815, 815,
    815, 875, 875, 875, 875, 875, 875, 525, 598, 607, 518, 607, 607, 607, 607, 607, 607, 607, 607,
    607, 607, 607, 610, 517, 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, 610, 995, 514, 995,
    610, 610, 610, 610, 610, 610, 826, 826, 826, 826, 826, 826, 826, 826, 826, 826, 819, 820, 839,
    819, 820, 839, 997, 512, 997, 610, 610, 610, 610, 610, 610, 613, 613, 613, 613, 613, 613, 613,
    613, 613, 613, 613, 819, 820, 839, 613, 613, 613, 613, 613, 613, 830, 511, 830, 830, 830, 830,
    830, 830, 1008, 1009, 1008, 1009, 841, 820, 1012, 841, 1012, 508, 507, 613, 613, 613, 613, 613,
    613, 614, 506, 614, 614, 614, 614, 614, 614, 614, 614, 614, 614, 617, 841, 617, 617, 617, 617,
    617, 617, 617, 617, 617, 617, 624, 624, 624, 624, 624, 624, 624, 624, 624, 624, 624, 624, 624,
    1013, 500, 1013, 624, 624, 624, 624, 624, 624, 825, 499, 825, 825, 825, 825, 825, 825, 843,
    843, 843, 843, 843, 843, 843, 843, 843, 843, 497, 624, 624, 624, 624, 624, 624, 627, 627, 627,
    627, 627, 627, 627, 627, 627, 627, 627, 627, 848, 496, 825, 848, 627, 627, 627, 627, 627, 627,
    847, 495, 847, 847, 847, 847, 847, 847, 494, 1018, 1017, 1018, 858, 1017, 464, 858, 848, 1017,
    463, 627, 627, 627, 627, 627, 627, 630, 460, 630, 630, 630, 630, 630, 630, 630, 630, 630, 630,
    631, 858, 894, 894, 894, 894, 894, 894, 631, 459, 458, 631, 631, 457, 631, 631, 631, 631, 631,
    631, 631, 631, 631, 631, 631, 631, 631, 1019, 451, 1019, 631, 631, 631, 631, 631, 631, 631,
    631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631,
    631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 631, 655, 450,
    882, 655, 882, 882, 882, 882, 882, 882, 449, 655, 448, 447, 446, 655, 655, 655, 655, 655, 655,
    655, 655, 655, 655, 655, 655, 655, 445, 444, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655,
    655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 443, 655, 655, 655, 655, 655,
    655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 655, 661, 442, 661, 661, 661, 661,
    661, 661, 661, 661, 661, 661, 852, 852, 852, 852, 852, 852, 852, 852, 852, 852, 853, 853, 853,
    853, 853, 853, 853, 853, 853, 853, 441, 440, 439, 438, 437, 436, 432, 661, 668, 431, 668, 668,
    668, 668, 668, 668, 668, 668, 668, 668, 674, 426, 674, 674, 674, 674, 674, 674, 674, 674, 674,
    674, 674, 677, 425, 677, 677, 677, 677, 677, 677, 677, 677, 677, 677, 677, 424, 418, 417, 677,
    677, 677, 677, 677, 677, 854, 854, 854, 854, 854, 854, 854, 854, 854, 854, 871, 415, 871, 871,
    871, 871, 871, 871, 414, 677, 677, 677, 677, 677, 677, 680, 680, 680, 680, 680, 680, 680, 680,
    680, 680, 680, 413, 412, 411, 680, 680, 680, 680, 680, 680, 410, 409, 408, 407, 871, 873, 873,
    873, 873, 873, 873, 873, 873, 873, 873, 404, 403, 402, 401, 680, 680, 680, 680, 680, 680, 681,
    385, 681, 681, 681, 681, 681, 681, 681, 681, 681, 681, 692, 692, 692, 692, 692, 692, 692, 692,
    692, 692, 692, 692, 716, 384, 716, 716, 716, 716, 716, 716, 716, 716, 716, 716, 722, 722, 722,
    722, 722, 722, 722, 722, 722, 722, 874, 874, 874, 874, 874, 874, 874, 874, 874, 874, 878, 878,
    878, 878, 878, 878, 878, 878, 878, 878, 383, 382, 380, 379, 375, 374, 373, 722, 724, 371, 724,
    724, 724, 724, 724, 724, 724, 724, 724, 724, 886, 886, 886, 886, 886, 886, 886, 886, 886, 886,
    887, 887, 887, 887, 887, 887, 887, 887, 887, 887, 370, 369, 368, 367, 366, 365, 364, 724, 739,
    361, 739, 739, 739, 739, 739, 739, 739, 739, 739, 739, 739, 742, 356, 742, 742, 742, 742, 742,
    742, 742, 742, 742, 742, 742, 355, 354, 347, 742, 742, 742, 742, 742, 742, 888, 888, 888, 888,
    888, 888, 888, 888, 888, 888, 891, 891, 891, 891, 891, 891, 346, 345, 344, 742, 742, 742, 742,
    742, 742, 745, 745, 745, 745, 745, 745, 745, 745, 745, 745, 343, 337, 336, 334, 745, 745, 745,
    745, 745, 745, 333, 332, 891, 893, 893, 893, 893, 893, 893, 893, 893, 893, 893, 331, 330, 329,
    328, 327, 326, 745, 745, 745, 745, 745, 745, 746, 325, 746, 746, 746, 746, 746, 746, 746, 746,
    746, 746, 749, 749, 749, 749, 749, 749, 749, 749, 749, 749, 749, 753, 322, 321, 319, 311, 310,
    307, 306, 753, 296, 294, 753, 753, 293, 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, 753,
    753, 753, 292, 291, 290, 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, 753,
    753, 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, 753, 753,
    753, 753, 753, 753, 753, 753, 753, 753, 753, 753, 771, 771, 771, 771, 771, 289, 771, 771, 288,
    287, 771, 286, 285, 284, 283, 280, 277, 276, 269, 266, 265, 264, 263, 262, 771, 771, 771, 773,
    773, 773, 773, 773, 259, 773, 773, 258, 257, 773, 256, 255, 254, 252, 251, 250, 249, 248, 247,
    246, 245, 244, 243, 773, 773, 773, 783, 242, 783, 783, 783, 783, 783, 783, 783, 783, 783, 783,
    784, 236, 784, 784, 784, 784, 784, 784, 784, 784, 784, 784, 785, 235, 785, 785, 785, 785, 785,
    785, 785, 785, 785, 785, 788, 225, 788, 788, 788, 788, 788, 788, 788, 788, 788, 788, 795, 224,
    795, 795, 795, 795, 795, 795, 795, 795, 795, 795, 795, 798, 223, 798, 798, 798, 798, 798, 798,
    798, 798, 798, 798, 222, 220, 219, 218, 798, 798, 798, 798, 798, 798, 217, 215, 209, 201, 197,
    192, 191, 189, 185, 180, 178, 173, 161, 160, 159, 158, 157, 149, 148, 798, 798, 798, 798, 798,
    798, 801, 147, 801, 801, 801, 801, 801, 801, 801, 801, 801, 801, 818, 146, 818, 818, 818, 818,
    818, 818, 818, 818, 818, 818, 821, 145, 821, 821, 821, 821, 821, 821, 821, 821, 821, 821, 823,
    144, 823, 823, 823, 823, 823, 823, 823, 823, 823, 823, 824, 142, 824, 824, 824, 824, 824, 824,
    824, 824, 824, 824, 836, 141, 836, 836, 836, 836, 836, 836, 836, 836, 836, 836, 849, 140, 849,
    849, 849, 849, 849, 849, 849, 849, 849, 849, 850, 139, 850, 850, 850, 850, 850, 850, 850, 850,
    850, 850, 851, 138, 851, 851, 851, 851, 851, 851, 851, 851, 851, 851, 866, 137, 866, 866, 866,
    866, 866, 866, 866, 866, 866, 866, 867, 133, 867, 867, 867, 867, 867, 867, 867, 867, 867, 867,
    869, 129, 869, 869, 869, 869, 869, 869, 869, 869, 869, 869, 870, 128, 870, 870, 870, 870, 870,
    870, 870, 870, 870, 870, 883, 883, 883, 883, 883, 883, 883, 883, 883, 883, 124, 121, 118, 117,
    114, 111, 107, 103, 102, 101, 100, 99, 95, 82, 75, 68, 67, 63, 62, 61, 58, 56, 54, 45, 44, 42,
    41, 883, 884, 884, 884, 884, 884, 884, 884, 884, 884, 884, 36, 32, 26, 20, 19, 16, 15, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 884, 885, 885, 885, 885, 885, 885, 885, 885,
    885, 885, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 885,
    890, 890, 890, 890, 890, 890, 890, 890, 890, 890, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 890, 896, 896, 896, 896, 896, 896, 896, 896, 896, 896, 896,
    896, 896, 896, 896, 896, 896, 896, 896, 896, 896, 897, 897, 897, 897, 897, 897, 897, 897, 897,
    897, 897, 897, 897, 897, 897, 897, 897, 897, 897, 897, 897, 898, 898, 898, 898, 898, 898, 898,
    898, 898, 898, 898, 898, 898, 898, 898, 898, 898, 898, 898, 898, 898, 899, 899, 899, 899, 899,
    899, 899, 899, 899, 899, 899, 899, 899, 899, 899, 899, 899, 899, 899, 899, 899, 900, 0, 0, 0,
    0, 0, 0, 900, 0, 900, 900, 900, 900, 0, 0, 900, 900, 900, 900, 900, 900, 901, 901, 901, 901,
    901, 901, 901, 901, 901, 901, 901, 901, 901, 901, 901, 901, 901, 901, 901, 901, 901, 902, 0, 0,
    0, 0, 902, 0, 902, 0, 902, 902, 902, 902, 902, 0, 902, 902, 902, 902, 902, 902, 903, 0, 0, 0,
    0, 0, 0, 903, 0, 903, 903, 903, 903, 0, 0, 903, 903, 903, 903, 903, 903, 904, 0, 0, 904, 904,
    0, 904, 904, 0, 904, 904, 904, 904, 0, 0, 904, 904, 904, 904, 904, 904, 905, 905, 0, 905, 0, 0,
    0, 905, 907, 0, 0, 907, 907, 0, 907, 907, 0, 907, 907, 907, 907, 0, 0, 907, 907, 907, 907, 907,
    907, 908, 0, 0, 908, 908, 0, 908, 908, 0, 908, 908, 908, 908, 0, 908, 908, 908, 0, 908, 908,
    908, 910, 0, 0, 910, 0, 0, 910, 910, 0, 910, 910, 910, 910, 910, 0, 910, 910, 910, 910, 910,
    910, 911, 911, 911, 911, 911, 911, 911, 911, 911, 911, 911, 911, 911, 911, 911, 911, 911, 911,
    911, 911, 911, 912, 912, 0, 912, 0, 912, 912, 912, 912, 912, 912, 912, 912, 912, 912, 912, 912,
    912, 912, 912, 912, 913, 0, 0, 0, 0, 913, 0, 913, 0, 913, 913, 913, 913, 913, 0, 913, 913, 913,
    913, 913, 913, 914, 0, 0, 0, 0, 0, 0, 914, 0, 914, 914, 914, 914, 0, 914, 914, 914, 914, 914,
    914, 914, 915, 0, 0, 915, 915, 0, 915, 915, 0, 915, 915, 915, 915, 0, 915, 915, 915, 915, 915,
    915, 915, 916, 916, 916, 916, 916, 916, 916, 916, 916, 916, 916, 916, 916, 916, 916, 916, 916,
    916, 916, 916, 916, 917, 917, 0, 917, 917, 917, 917, 917, 917, 917, 917, 917, 917, 917, 917,
    917, 917, 917, 917, 917, 917, 918, 0, 0, 0, 0, 0, 0, 918, 0, 918, 918, 918, 918, 0, 0, 918,
    918, 918, 918, 918, 918, 920, 0, 0, 0, 0, 0, 0, 920, 0, 920, 920, 920, 920, 0, 0, 920, 920,
    920, 920, 920, 920, 921, 0, 0, 921, 921, 0, 921, 921, 0, 921, 921, 921, 921, 0, 0, 921, 921,
    921, 921, 921, 921, 922, 0, 0, 922, 922, 0, 922, 922, 0, 922, 922, 922, 922, 0, 0, 922, 922,
    922, 922, 922, 922, 923, 923, 0, 923, 0, 0, 0, 923, 924, 924, 0, 924, 0, 0, 0, 924, 925, 925,
    925, 0, 925, 0, 0, 0, 925, 926, 0, 0, 926, 926, 0, 926, 926, 0, 926, 926, 926, 926, 0, 0, 926,
    926, 926, 926, 926, 926, 927, 0, 0, 927, 927, 0, 927, 927, 0, 927, 927, 927, 927, 0, 0, 927,
    927, 927, 927, 927, 927, 928, 0, 0, 928, 928, 0, 928, 928, 0, 928, 928, 928, 928, 0, 928, 928,
    928, 0, 928, 928, 928, 930, 0, 0, 930, 0, 0, 930, 930, 0, 930, 930, 930, 930, 930, 0, 930, 930,
    930, 930, 930, 930, 931, 931, 0, 931, 0, 931, 931, 931, 931, 931, 931, 931, 931, 931, 931, 931,
    931, 931, 931, 931, 931, 932, 0, 0, 0, 0, 0, 0, 932, 0, 932, 932, 932, 932, 0, 0, 932, 932,
    932, 932, 932, 932, 933, 0, 0, 0, 0, 0, 0, 933, 0, 933, 933, 933, 933, 0, 933, 933, 933, 933,
    933, 933, 933, 934, 0, 0, 934, 934, 0, 934, 934, 0, 934, 934, 934, 934, 0, 934, 934, 934, 934,
    934, 934, 934, 935, 0, 0, 935, 935, 0, 935, 936, 936, 936, 936, 936, 936, 936, 936, 936, 936,
    936, 936, 936, 936, 936, 936, 936, 936, 936, 936, 936, 937, 937, 0, 937, 0, 0, 0, 937, 938,
    938, 938, 0, 938, 0, 0, 0, 938, 941, 941, 0, 941, 0, 0, 0, 941, 942, 942, 0, 942, 0, 0, 0, 942,
    943, 943, 0, 943, 0, 0, 0, 943, 944, 944, 944, 0, 944, 0, 0, 0, 944, 945, 0, 0, 945, 945, 0,
    945, 946, 946, 0, 946, 0, 0, 0, 946, 947, 947, 0, 947, 0, 0, 0, 947, 948, 948, 0, 948, 0, 0, 0,
    948, 949, 949, 949, 0, 949, 0, 0, 0, 949, 950, 950, 950, 950, 0, 950, 0, 0, 0, 950, 953, 953,
    0, 953, 0, 0, 0, 953, 954, 954, 0, 954, 0, 0, 0, 954, 955, 955, 0, 955, 0, 0, 0, 955, 958, 958,
    958, 0, 958, 0, 0, 0, 958, 959, 959, 959, 959, 0, 959, 0, 0, 0, 959, 960, 960, 960, 960, 960,
    960, 960, 960, 960, 960, 960, 960, 960, 960, 960, 960, 960, 960, 960, 960, 960, 962, 962, 0,
    962, 0, 0, 0, 962, 963, 963, 0, 963, 0, 0, 0, 963, 965, 965, 965, 0, 965, 0, 0, 0, 965, 966,
    966, 966, 966, 0, 966, 0, 0, 0, 966, 967, 967, 967, 967, 967, 967, 967, 967, 967, 967, 967,
    967, 967, 967, 967, 967, 967, 967, 967, 967, 967, 970, 0, 0, 970, 970, 0, 970, 971, 0, 0, 0,
    971, 971, 0, 971, 971, 971, 0, 0, 971, 971, 972, 972, 0, 972, 0, 0, 0, 972, 973, 0, 973, 973,
    0, 973, 0, 0, 0, 973, 976, 976, 976, 0, 976, 0, 0, 0, 976, 977, 977, 977, 977, 0, 977, 0, 0, 0,
    977, 978, 978, 0, 0, 978, 0, 0, 0, 978, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 979,
    979, 979, 979, 979, 979, 979, 979, 979, 979, 979, 981, 0, 0, 981, 981, 0, 981, 982, 0, 0, 0,
    982, 982, 0, 982, 982, 982, 0, 0, 982, 982, 985, 985, 0, 985, 0, 0, 0, 985, 986, 0, 986, 986,
    0, 986, 0, 0, 0, 986, 987, 987, 0, 987, 0, 0, 0, 987, 989, 989, 989, 0, 989, 0, 0, 0, 989, 990,
    990, 990, 0, 0, 990, 0, 0, 0, 990, 991, 991, 991, 991, 991, 991, 991, 991, 991, 991, 991, 991,
    991, 991, 991, 991, 991, 991, 991, 991, 991, 992, 992, 0, 992, 992, 992, 0, 992, 0, 992, 992,
    992, 992, 0, 0, 992, 992, 992, 992, 992, 992, 993, 993, 0, 993, 993, 993, 0, 993, 0, 993, 993,
    993, 993, 0, 0, 993, 993, 993, 993, 993, 993, 996, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 996, 996, 0,
    996, 996, 0, 996, 998, 998, 0, 998, 0, 0, 0, 998, 999, 0, 999, 999, 0, 999, 0, 0, 0, 999, 1002,
    1002, 0, 0, 1002, 0, 0, 0, 1002, 1003, 1003, 1003, 1003, 1003, 1003, 1003, 1003, 1003, 1003,
    1003, 1003, 1003, 1003, 1003, 1003, 1003, 1003, 1003, 1003, 1003, 1004, 1004, 1004, 1004, 1004,
    1004, 1004, 1004, 1004, 1004, 1004, 1004, 1004, 1004, 1004, 1004, 1004, 1004, 1004, 1004, 1004,
    1005, 0, 0, 0, 0, 0, 0, 1005, 0, 1005, 1005, 1005, 1005, 0, 0, 1005, 1005, 1005, 1005, 1005,
    1005, 1007, 0, 0, 0, 0, 0, 0, 1007, 0, 1007, 1007, 1007, 1007, 0, 0, 1007, 1007, 1007, 1007,
    1007, 1007, 1010, 1010, 0, 1010, 0, 0, 0, 1010, 1011, 0, 1011, 1011, 0, 1011, 0, 0, 0, 1011,
    1014, 1014, 0, 1014, 0, 0, 0, 1014, 1015, 0, 1015, 0, 0, 1015, 0, 0, 0, 1015, 1016, 1016, 1016,
    1016, 1016, 1016, 1016, 1016, 1016, 1016, 1016, 1016, 1016, 1016, 1016, 1016, 1016, 1016, 1016,
    1016, 1016, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
    895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
    895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
    895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895, 895,
    895,
];

/*
 * Compare two struct path_list structs in reverse order.
 */
unsafe extern "C" fn pl_compare(
    mut v1: *const libc::c_void,
    mut v2: *const libc::c_void,
) -> libc::c_int {
    let mut p1: *const *const path_list = v1 as *const *const path_list;
    let mut p2: *const *const path_list = v2 as *const *const path_list;
    strcmp((**p2).path, (**p1).path)
}

/*
 * Open dirpath and fill in pathsp with an array of regular files
 * that do not end in '~' or contain a '.'.
 * Returns the number of files or -1 on error.
 * If zero files are found, NULL is stored in pathsp.
 */
fn read_dir_files(
    mut dirpath: *const libc::c_char,
    mut pathsp: *mut *mut *mut path_list,
) -> libc::c_int {
    let mut dir: *mut DIR = std::ptr::null_mut::<DIR>();
    let mut i: libc::c_int = 0;
    let mut count: libc::c_int = 0 as libc::c_int;
    let mut max_paths: libc::c_int = 32 as libc::c_int;
    let mut dent: *mut dirent = std::ptr::null_mut::<dirent>();
    let mut paths: *mut *mut path_list = std::ptr::null_mut::<*mut path_list>();

    unsafe {
        debug_decl!(SUDOERS_DEBUG_PARSER!());

        'bad: loop {
            dir = opendir(dirpath);
            if dir.is_null() {
                if *__errno_location() == ENOENT {
                    // goto done
                    *pathsp = paths;
                    debug_return_int!(count);
                }

                sudo_warn!(b"%s\0" as *const u8 as *const libc::c_char, dirpath);
                // goto bad;
                break 'bad;
            }

            paths = reallocarray(
                std::ptr::null_mut::<libc::c_void>(),
                max_paths as size_t,
                ::core::mem::size_of::<*mut path_list>() as libc::c_ulong,
            ) as *mut *mut path_list;

            if paths.is_null() {
                // goto oom;
                // oom:
                sudo_warnx!(
                    b"%s: %s\0" as *const u8 as *const libc::c_char,
                    get_function_name!(),
                    b"unable to allocate memory\0" as *const u8 as *const libc::c_char
                );

                break 'bad;
            }

            dent = readdir(dir);
            loop {
                if dent.is_null() {
                    break;
                }
                let mut pl: *mut path_list = std::ptr::null_mut::<path_list>();
                let mut sb: stat = sb_all_arch;
                let mut len: size_t = 0;
                let mut path: *mut libc::c_char = std::ptr::null_mut::<libc::c_char>();

                /* Ignore files that end in '~' or have a '.' in them. */
                if (*dent).d_name[0 as libc::c_int as usize] as libc::c_int == '\0' as i32
                    || (*dent).d_name[(strlen(((*dent).d_name).as_mut_ptr()))
                        .wrapping_sub(1 as libc::c_int as libc::c_ulong)
                        as usize] as libc::c_int
                        == '~' as i32
                    || !(strchr(((*dent).d_name).as_mut_ptr(), '.' as i32)).is_null()
                {
                    dent = readdir(dir);
                    continue;
                }

                len = (strlen(dirpath))
                    .wrapping_add(1 as libc::c_int as libc::c_ulong)
                    .wrapping_add(strlen(((*dent).d_name).as_mut_ptr()));
                path = rcstr_alloc(len);
                if path.is_null() {
                    // goto oom;
                    // oom:
                    sudo_warnx!(
                        b"%s: %s\0" as *const u8 as *const libc::c_char,
                        get_function_name!(),
                        b"unable to allocate memory\0" as *const u8 as *const libc::c_char
                    );

                    break 'bad;
                }
                snprintf(
                    path,
                    len.wrapping_add(1 as libc::c_int as libc::c_ulong),
                    b"%s/%s\0" as *const u8 as *const libc::c_char,
                    dirpath,
                    ((*dent).d_name).as_mut_ptr(),
                );
                if stat(path, &mut sb) != 0 as libc::c_int
                    || (sb.st_mode & 0o170000 as libc::c_int as libc::c_uint
                        != 0o100000 as libc::c_int as libc::c_uint)
                {
                    rcstr_delref(path);
                    dent = readdir(dir);
                    continue;
                }
                pl = malloc(::core::mem::size_of::<path_list>() as libc::c_ulong) as *mut path_list;
                if pl.is_null() {
                    rcstr_delref(path);
                    // goto oom;
                    // oom:
                    sudo_warnx!(
                        b"%s: %s\0" as *const u8 as *const libc::c_char,
                        get_function_name!(),
                        b"unable to allocate memory\0" as *const u8 as *const libc::c_char
                    );

                    break 'bad;
                }

                (*pl).path = path;
                if count >= max_paths {
                    let mut tmp: *mut *mut path_list = std::ptr::null_mut::<*mut path_list>();
                    max_paths <<= 1 as libc::c_int;
                    tmp = reallocarray(
                        paths as *mut libc::c_void,
                        max_paths as size_t,
                        ::core::mem::size_of::<*mut path_list>() as libc::c_ulong,
                    ) as *mut *mut path_list;
                    if tmp.is_null() {
                        rcstr_delref(path);
                        free(pl as *mut libc::c_void);
                        // goto oom;
                        // oom:
                        sudo_warnx!(
                            b"%s: %s\0" as *const u8 as *const libc::c_char,
                            get_function_name!(),
                            b"unable to allocate memory\0" as *const u8 as *const libc::c_char
                        );
                    }
                    paths = tmp;
                }

                let fresh0 = count;
                count += 1;
                let fresh1 = &mut *paths.offset(fresh0 as isize);
                *fresh1 = pl;

                dent = readdir(dir);
            } // loop

            closedir(dir);
            if count == 0 {
                free(paths as *mut libc::c_void);
                paths = std::ptr::null_mut::<*mut path_list>();
            }

            // done:
            *pathsp = paths;
            debug_return_int!(count);
        } // 'bad: loop

        // bad:
        sudoerserror(std::ptr::null::<libc::c_char>());
        if !dir.is_null() {
            closedir(dir);
        }
        i = 0 as libc::c_int;
        while i < count {
            rcstr_delref((**paths.offset(i as isize)).path);
            free(*paths.offset(i as isize) as *mut libc::c_void);
            i += 1;
        }
        free(paths as *mut libc::c_void);
        debug_return_int!(-1);
    }
}

/*
 * Push a list of all files in dirpath onto stack.
 * Returns the number of files or -1 on error.
 */
fn switch_dir(mut stack: *mut include_stack, mut dirpath: *mut libc::c_char) -> libc::c_int {
    let mut paths: *mut *mut path_list = std::ptr::null_mut::<*mut path_list>();
    let mut count: libc::c_int = 0;
    let mut i: libc::c_int = 0;
    unsafe {
        debug_decl!(SUDOERS_DEBUG_PARSER!());

        count = read_dir_files(dirpath, &mut paths);
        if count > 0 as libc::c_int {
            /* Sort the list as an array in reverse order. */
            qsort(
                paths as *mut libc::c_void,
                count as size_t,
                ::core::mem::size_of::<*mut path_list>() as libc::c_ulong,
                Some(
                    pl_compare
                        as unsafe extern "C" fn(
                            *const libc::c_void,
                            *const libc::c_void,
                        ) -> libc::c_int,
                ),
            );

            /* Build up the list in sorted order. */
            i = 0 as libc::c_int;
            while i < count {
                let fresh2 = &mut (**paths.offset(i as isize)).entries.sle_next;
                *fresh2 = (*stack).more.slh_first;
                (*stack).more.slh_first = *paths.offset(i as isize);
                i += 1;
            }
            free(paths as *mut libc::c_void);
        }
        debug_return_int!(count);
    }
}
static mut istacksize: size_t = 0;
static mut idepth: size_t = 0;
static mut istack: *mut include_stack = 0 as *const include_stack as *mut include_stack;
static mut keepopen: bool = false;

#[no_mangle]
pub fn init_lexer() {
    let mut pl: *mut path_list = std::ptr::null_mut::<path_list>();
    unsafe {
        debug_decl!(SUDOERS_DEBUG_PARSER!());

        while idepth != 0 {
            idepth = idepth.wrapping_sub(1);
            loop {
                pl = (*istack.offset(idepth as isize)).more.slh_first;
                if pl.is_null() {
                    break;
                }
                let fresh3 = &mut (*istack.offset(idepth as isize)).more.slh_first;
                *fresh3 = (*(*istack.offset(idepth as isize)).more.slh_first)
                    .entries
                    .sle_next;
                rcstr_delref((*pl).path);
                free(pl as *mut libc::c_void);
            }
            rcstr_delref((*istack.offset(idepth as isize)).path);
            if idepth != 0 && !(*istack.offset(idepth as isize)).keepopen {
                fclose((*(*istack.offset(idepth as isize)).bs).yy_input_file);
            }
            sudoers_delete_buffer((*istack.offset(idepth as isize)).bs);
        }
        free(istack as *mut libc::c_void);
        istack = std::ptr::null_mut::<include_stack>();
        idepth = 0 as libc::c_int as size_t;
        istacksize = idepth;
        sudolineno = 1;
        keepopen = false;
        sawspace = false;
        continued = false;
        digest_type = -(1 as libc::c_int);
        prev_state = INITIAL;

        debug_return!();
    }
}

/*
 * Open an include file (or file from a directory), push the old
 * sudoers file buffer and switch to the new one.
 * A missing or insecure include dir is simply ignored.
 * Returns false on error, else true.
 */
fn push_include_int(mut path: *mut libc::c_char, mut isdir: bool) -> bool {
    let mut pl: *mut path_list = std::ptr::null_mut::<path_list>();
    let mut fp: *mut FILE = std::ptr::null_mut::<FILE>();
    unsafe {
        debug_decl!(SUDOERS_DEBUG_PARSER!());

        /* push current state onto stack */
        if idepth >= istacksize {
            let mut new_istack: *mut include_stack = std::ptr::null_mut::<include_stack>();
            if idepth > MAX_SUDOERS_DEPTH {
                sudoerserror(b"too many levels of includes\0" as *const u8 as *const libc::c_char);
                debug_return_bool!(false);
            }
            istacksize = (istacksize as libc::c_ulong).wrapping_add(SUDOERS_STACK_INCREMENT)
                as size_t as size_t;
            new_istack = reallocarray(
                istack as *mut libc::c_void,
                istacksize,
                ::core::mem::size_of::<include_stack>() as libc::c_ulong,
            ) as *mut include_stack;
            if new_istack.is_null() {
                sudo_warnx!(
                    b"%s: %s\0" as *const u8 as *const libc::c_char,
                    get_function_name!(),
                    b"unable to allocate memory\0" as *const u8 as *const libc::c_char
                );

                sudoerserror(std::ptr::null::<libc::c_char>());
                debug_return_bool!(false);
            }
            istack = new_istack;
        }
        let fresh4 = &mut (*istack.offset(idepth as isize)).more.slh_first;
        *fresh4 = std::ptr::null_mut::<path_list>();
        if isdir {
            let mut sb: stat = sb_all_arch;
            let mut count: libc::c_int = 0;
            let mut status: libc::c_int = 0;
            status = sudo_secure_dir_v1(path, sudoers_uid, sudoers_gid, &mut sb);
            if status != SUDO_PATH_SECURE {
                if sudoers_warnings {
                    match status {
                        SUDO_PATH_BAD_TYPE => {
                            *__errno_location() = ENOTDIR;
                            sudo_warn!(b"%s\0" as *const u8 as *const libc::c_char, path);
                        }
                        SUDO_PATH_WRONG_OWNER => {
                            sudo_warnx!(
                                b"%s is owned by uid %u, should be %u\0" as *const u8
                                    as *const libc::c_char,
                                path,
                                sb.st_uid,
                                sudoers_uid
                            );
                        }
                        SUDO_PATH_WORLD_WRITABLE => {
                            sudo_warnx!(
                                b"%s is world writable\0" as *const u8 as *const libc::c_char,
                                path
                            );
                        }
                        SUDO_PATH_GROUP_WRITABLE => {
                            sudo_warnx!(
                                b"%s is owned by gid %u, should be %u\0" as *const u8
                                    as *const libc::c_char,
                                path,
                                sb.st_gid,
                                sudoers_gid,
                            );
                        }
                        _ => {}
                    }
                }

                /* A missing or insecure include dir is not a fatal error. */
                debug_return_bool!(true);
            }

            count = switch_dir(&mut *istack.offset(idepth as isize), path);
            if count <= 0 as libc::c_int {
                /* switch_dir() called sudoerserror() for us */
                rcstr_delref(path);
                debug_return_bool!(count == 0);
            }

            /* Parse the first dir entry we can open, leave the rest for later. */
            loop {
                rcstr_delref(path);
                pl = (*istack.offset(idepth as isize)).more.slh_first;
                if pl.is_null() {
                    /* Unable to open any files in include dir, not an error. */
                    debug_return_bool!(true);
                }
                let fresh5 = &mut (*istack.offset(idepth as isize)).more.slh_first;
                *fresh5 = (*(*istack.offset(idepth as isize)).more.slh_first)
                    .entries
                    .sle_next;
                path = (*pl).path;
                free(pl as *mut libc::c_void);
                fp = open_sudoers(path, 0 as libc::c_int != 0, &mut keepopen);
                if !fp.is_null() {
                    break;
                }
            }
        } else {
            fp = open_sudoers(path, 1 as libc::c_int != 0, &mut keepopen);
            if fp.is_null() {
                /* The error was already printed by open_sudoers() */
                sudoerserror(std::ptr::null::<libc::c_char>());
                debug_return_bool!(false);
            }
        }

        /* Push the old (current) file and open the new one. */
        let fresh6 = &mut (*istack.offset(idepth as isize)).path;
        *fresh6 = sudoers; /* push old path (and its ref) */
        let fresh7 = &mut (*istack.offset(idepth as isize)).bs;
        *fresh7 = if !yy_buffer_stack.is_null() {
            *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
        } else {
            0 as YY_BUFFER_STATE
        };
        (*istack.offset(idepth as isize)).lineno = sudolineno;
        (*istack.offset(idepth as isize)).keepopen = keepopen;

        idepth = idepth.wrapping_add(1);
        sudolineno = 1 as libc::c_int;
        sudoers = path;
        sudoers_switch_to_buffer(sudoers_create_buffer(fp, 16384 as libc::c_int));
        debug_return_bool!(true);
    }
}

/*
 * Restore the previous sudoers file and buffer, or, in the case
 * of an includedir, switch to the next file in the dir.
 * Returns false if there is nothing to pop, else true.
 */
fn pop_include() -> bool {
    let mut pl: *mut path_list = std::ptr::null_mut::<path_list>();
    let mut fp: *mut FILE = std::ptr::null_mut::<FILE>();
    unsafe {
        debug_decl!(SUDOERS_DEBUG_PARSER!());

        if idepth == 0 as libc::c_int as libc::c_ulong
            || (if !yy_buffer_stack.is_null() {
                *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
            } else {
                0 as YY_BUFFER_STATE
            })
            .is_null()
        {
            debug_return_bool!(false);
        }
        if !keepopen {
            fclose(
                (*if !yy_buffer_stack.is_null() {
                    *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
                } else {
                    0 as YY_BUFFER_STATE
                })
                .yy_input_file,
            );
        }
        sudoers_delete_buffer(if !yy_buffer_stack.is_null() {
            *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
        } else {
            0 as YY_BUFFER_STATE
        });

        /* If we are in an include dir, move to the next file. */
        loop {
            pl = (*istack.offset(idepth.wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize))
                .more
                .slh_first;
            if pl.is_null() {
                break;
            }
            let fresh8 = &mut (*istack
                .offset(idepth.wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize))
            .more
            .slh_first;
            *fresh8 = (*(*istack
                .offset(idepth.wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize))
            .more
            .slh_first)
                .entries
                .sle_next;
            fp = open_sudoers((*pl).path, 0 as libc::c_int != 0, &mut keepopen);
            if !fp.is_null() {
                rcstr_delref(sudoers);
                sudoers = (*pl).path;
                sudolineno = 1 as libc::c_int;
                sudoers_switch_to_buffer(sudoers_create_buffer(fp, 16384 as libc::c_int));
                free(pl as *mut libc::c_void);
                break;
            } else {
                /* Unable to open path in include dir, go to next one. */
                rcstr_delref((*pl).path);
                free(pl as *mut libc::c_void);
            }
        }
        /* If no path list, just pop the last dir on the stack. */
        if pl.is_null() {
            idepth = idepth.wrapping_sub(1);
            sudoers_switch_to_buffer((*istack.offset(idepth as isize)).bs);
            rcstr_delref(sudoers);
            sudoers = (*istack.offset(idepth as isize)).path;
            sudolineno = (*istack.offset(idepth as isize)).lineno;
            keepopen = (*istack.offset(idepth as isize)).keepopen;
        }
        debug_return_bool!(true);
    }
}
fn parse_include_int(mut base: *const libc::c_char, mut isdir: bool) -> *mut libc::c_char {
    let mut cp: *const libc::c_char = std::ptr::null::<libc::c_char>();
    let mut ep: *const libc::c_char = std::ptr::null::<libc::c_char>();
    let mut path: *mut libc::c_char = std::ptr::null_mut::<libc::c_char>();
    let mut pp: *mut libc::c_char = std::ptr::null_mut::<libc::c_char>();
    let mut dirlen: libc::c_int = 0 as libc::c_int;
    let mut len: libc::c_int = 0 as libc::c_int;
    let mut subst: libc::c_int = 0 as libc::c_int;
    let mut shost_len: size_t = 0 as libc::c_int as size_t;
    unsafe {
        debug_decl!(SUDOERS_DEBUG_PARSER!());

        /* Pull out path from #include line. */
        cp = base.offset(
            (if isdir as libc::c_int != 0 {
                ::core::mem::size_of::<[libc::c_char; 12]>() as libc::c_ulong
            } else {
                ::core::mem::size_of::<[libc::c_char; 9]>() as libc::c_ulong
            }) as isize,
        );
        while *(*__ctype_b_loc()).offset(*cp as libc::c_uchar as libc::c_int as isize)
            as libc::c_int
            & _ISblank as libc::c_int as libc::c_ushort as libc::c_int
            != 0
        {
            cp = cp.offset(1);
        }
        ep = cp;

        while *ep as libc::c_int != '\0' as i32
            && *(*__ctype_b_loc()).offset(*ep as libc::c_uchar as libc::c_int as isize)
                as libc::c_int
                & _ISspace as libc::c_int as libc::c_ushort as libc::c_int
                == 0
        {
            if *ep.offset(0 as libc::c_int as isize) as libc::c_int == '%' as i32
                && *ep.offset(1 as libc::c_int as isize) as libc::c_int == 'h' as i32
            {
                shost_len = strlen(user_shost!());
                len = (len as libc::c_ulong)
                    .wrapping_add(shost_len.wrapping_sub(2 as libc::c_int as libc::c_ulong))
                    as libc::c_int as libc::c_int;
                subst = 1 as libc::c_int;
            }
            ep = ep.offset(1);
        }

        /* Relative paths are located in the same dir as the sudoers file. */
        if *cp as libc::c_int != '/' as i32 {
            let mut dirend: *mut libc::c_char = strrchr(sudoers, '/' as i32);
            if !dirend.is_null() {
                dirlen =
                    dirend.offset_from(sudoers) as libc::c_long as libc::c_int + 1 as libc::c_int;
            }
        }

        /* Make a copy of the fully-qualified path and return it. */
        len += ep.offset_from(cp) as libc::c_long as libc::c_int;
        pp = rcstr_alloc((len + dirlen) as size_t);
        path = pp;
        if path.is_null() {
            sudo_warnx!(
                b"%s: %s\0" as *const u8 as *const libc::c_char,
                get_function_name!(),
                b"unable to allocate memory\0" as *const u8 as *const libc::c_char
            );
            sudoerserror(std::ptr::null::<libc::c_char>());
            debug_return_str!(std::ptr::null_mut::<libc::c_char>());
        }

        if dirlen != 0 {
            memcpy(
                path as *mut libc::c_void,
                sudoers as *const libc::c_void,
                dirlen as libc::c_ulong,
            );
            pp = pp.offset(dirlen as isize);
        }
        if subst != 0 {
            /* substitute for %h */
            while cp < ep {
                if *cp.offset(0 as libc::c_int as isize) as libc::c_int == '%' as i32
                    && *cp.offset(1 as libc::c_int as isize) as libc::c_int == 'h' as i32
                {
                    memcpy(
                        pp as *mut libc::c_void,
                        user_shost!() as *const libc::c_void,
                        shost_len,
                    );
                    pp = pp.offset(shost_len as isize);
                    cp = cp.offset(2 as libc::c_int as isize);
                } else {
                    let fresh9 = cp;
                    cp = cp.offset(1);
                    let fresh10 = pp;
                    pp = pp.offset(1);
                    *fresh10 = *fresh9;
                }
            }
            *pp = '\0' as i32 as libc::c_char;
        } else {
            memcpy(
                pp as *mut libc::c_void,
                cp as *const libc::c_void,
                len as libc::c_ulong,
            );
            *pp.offset(len as isize) = '\0' as i32 as libc::c_char;
        }

        /* Push any excess characters (e.g. comment, newline) back to the lexer */
        if *ep as libc::c_int != '\0' as i32 {
            let mut yyless_macro_arg: libc::c_int =
                ep.offset_from(base) as libc::c_long as libc::c_int;
            *sudoerstext.offset(sudoersleng as isize) = yy_hold_char;
            yy_c_buf_p = sudoerstext.offset(yyless_macro_arg as isize);
            yy_hold_char = *yy_c_buf_p;
            *yy_c_buf_p = '\0' as i32 as libc::c_char;
            sudoersleng = yyless_macro_arg as yy_size_t;
        }
        debug_return_str!(path);
    }
}
#[no_mangle]
pub unsafe extern "C" fn sudoers_trace_print(mut msg: *const libc::c_char) -> libc::c_int {
    static mut initialized: bool = false;
    static mut lbuf: sudo_lbuf = sudo_lbuf {
        output: None,
        buf: 0 as *const libc::c_char as *mut libc::c_char,
        continuation: 0 as *const libc::c_char,
        indent: 0,
        len: 0,
        size: 0,
        cols: 0,
        error: 0,
    };
    if !initialized {
        initialized = 1 as libc::c_int != 0;
        sudo_lbuf_init_v1(
            &mut lbuf,
            None,
            0 as libc::c_int,
            std::ptr::null::<libc::c_char>(),
            0 as libc::c_int,
        );
    }
    sudo_lbuf_append_v1(
        &mut lbuf as *mut sudo_lbuf,
        b"%s\0" as *const u8 as *const libc::c_char,
        msg,
    );
    /* XXX - assumes a final newline */
    if !(strchr(msg, '\n' as i32)).is_null() {
        sudo_debug_printf2_v1(
            std::ptr::null::<libc::c_char>(),
            std::ptr::null::<libc::c_char>(),
            0 as libc::c_int,
            SUDOERS_DEBUG_PARSER!() | SUDO_DEBUG_DEBUG,
            b"%s:%d %s\0" as *const u8 as *const libc::c_char,
            sudoers,
            sudolineno,
            lbuf.buf,
        );
        lbuf.len = 0 as libc::c_int;
    }
    0 as libc::c_int
}

static mut yy_last_accepting_state: yy_state_type = 0;
static mut yy_last_accepting_cpos: *mut libc::c_char =
    0 as *const libc::c_char as *mut libc::c_char;
#[no_mangle]
pub static mut sudoers_flex_debug: libc::c_int = 0 as libc::c_int;
#[no_mangle]
pub static mut sudoerstext: *mut libc::c_char = 0 as *const libc::c_char as *mut libc::c_char;
#[no_mangle]
pub fn sudoerslex() -> libc::c_int {
    let mut yy_amount_of_matched_text: libc::c_int = 0;
    let mut yy_next_state: yy_state_type = 0;
    let mut current_block: u64;
    let mut yy_current_state: yy_state_type = 0;
    let mut yy_cp: *mut libc::c_char = std::ptr::null_mut::<libc::c_char>();
    let mut yy_bp: *mut libc::c_char = std::ptr::null_mut::<libc::c_char>();
    let mut yy_act: libc::c_int = 0;
    unsafe {
        if yy_init == 0 {
            yy_init = 1 as libc::c_int;
            if yy_start == 0 {
                yy_start = 1 as libc::c_int;
            }
            if sudoersin.is_null() {
                sudoersin = stdin;
            }
            if sudoersout.is_null() {
                sudoersout = stdout;
            }
            if if !yy_buffer_stack.is_null() {
                *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
            } else {
                0 as YY_BUFFER_STATE
            }
            .is_null()
            {
                sudoersensure_buffer_stack();
                let fresh11 = &mut *yy_buffer_stack.offset(yy_buffer_stack_top as isize);
                *fresh11 = sudoers_create_buffer(sudoersin, 16384 as libc::c_int);
            }
            sudoers_load_buffer_state();
        }
        's_65: loop {
            yy_cp = yy_c_buf_p;
            *yy_cp = yy_hold_char;
            yy_bp = yy_cp;
            yy_current_state = yy_start;
            yy_current_state += (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_at_bol;
            '_yy_match: loop {
                loop {
                    let mut yy_c: YY_CHAR =
                        yy_ec[*yy_cp as libc::c_uchar as libc::c_uint as usize] as YY_CHAR;
                    if yy_accept[yy_current_state as usize] != 0 {
                        yy_last_accepting_state = yy_current_state;
                        yy_last_accepting_cpos = yy_cp;
                    }
                    while yy_chk[(yy_base[yy_current_state as usize] as libc::c_int
                        + yy_c as libc::c_int) as usize] as libc::c_int
                        != yy_current_state
                    {
                        yy_current_state = yy_def[yy_current_state as usize] as libc::c_int;
                        if yy_current_state >= 896 as libc::c_int {
                            yy_c = yy_meta[yy_c as libc::c_uint as usize] as YY_CHAR;
                        }
                    }
                    yy_current_state = yy_nxt[(yy_base[yy_current_state as usize] as libc::c_uint)
                        .wrapping_add(yy_c as libc::c_uint)
                        as usize] as yy_state_type;
                    yy_cp = yy_cp.offset(1);
                    if yy_base[yy_current_state as usize] as libc::c_int == 6207 as libc::c_int {
                        break;
                    }
                }
                '_yy_find_action: loop {
                    yy_act = yy_accept[yy_current_state as usize] as libc::c_int;
                    if yy_act == 0 as libc::c_int {
                        yy_cp = yy_last_accepting_cpos;
                        yy_current_state = yy_last_accepting_state;
                        yy_act = yy_accept[yy_current_state as usize] as libc::c_int;
                    }
                    sudoerstext = yy_bp;
                    sudoersleng = yy_cp.offset_from(yy_bp) as libc::c_long as size_t;
                    yy_hold_char = *yy_cp;
                    *yy_cp = '\0' as i32 as libc::c_char;
                    yy_c_buf_p = yy_cp;
                    loop {
                        match yy_act {
                            0 => {
                                *yy_cp = yy_hold_char;
                                yy_cp = yy_last_accepting_cpos;
                                yy_current_state = yy_last_accepting_state;
                                continue '_yy_find_action;
                            }
                            1 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //(Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b", \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = ',' as i32;
                                return ',' as i32;
                            }
                            2 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                yy_start = 1 as libc::c_int + 2 as libc::c_int * 3 as libc::c_int;
                                continue 's_65;
                            }
                            3 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                yy_start = 1 as libc::c_int + 2 as libc::c_int * 4 as libc::c_int;
                                if trace_print.is_some() {
                                    //                                  (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //                                        .expect("non-null function pointer")(
                                        b"DEFVAR \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                if !fill_txt(sudoerstext, sudoersleng, 0 as libc::c_int as size_t) {
                                    return 0 as libc::c_int;
                                }
                                last_token = 259 as libc::c_int;
                                return 259 as libc::c_int;
                            }
                            4 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                yy_start = 1 as libc::c_int + 2 as libc::c_int * 3 as libc::c_int;
                                if trace_print.is_some() {
                                    //                                 (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //                                       .expect("non-null function pointer")(
                                        b", \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = ',' as i32;
                                return ',' as i32;
                            }
                            5 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                    (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //                                      .expect("non-null function pointer")(
                                        b"= \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = '=' as i32;
                                return '=' as i32;
                            }
                            6 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                   (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //                                     .expect("non-null function pointer")(
                                        b"+= \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = '+' as i32;
                                return '+' as i32;
                            }
                            7 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //(Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"-= \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = '-' as i32;
                                return '-' as i32;
                            }
                            8 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //(Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"BEGINSTR \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                sudoerslval.string = std::ptr::null_mut::<libc::c_char>();
                                prev_state = (yy_start - 1 as libc::c_int) / 2 as libc::c_int;
                                yy_start = 1 as libc::c_int + 2 as libc::c_int * 5 as libc::c_int;
                                continue 's_65;
                            }
                            9 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //(Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"WORD(2) \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                if !fill_txt(sudoerstext, sudoersleng, 0 as libc::c_int as size_t) {
                                    return 0 as libc::c_int;
                                }
                                last_token = 263 as libc::c_int;
                                return 263 as libc::c_int;
                            }
                            10 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                sudolineno += 1;
                                continued = 1 as libc::c_int != 0;
                                continue 's_65;
                            }
                            11 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //(Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"ENDSTR \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                yy_start = 1 as libc::c_int + 2 as libc::c_int * prev_state;
                                if (sudoerslval.string).is_null() {
                                    if trace_print.is_some() {
                                        //(Some(trace_print.expect("non-null function pointer")))
                                        trace_print.expect("non-null function pointer")(
                                            //.expect("non-null function pointer")(
                                            b"ERROR \0" as *const u8 as *const libc::c_char,
                                        );
                                    }
                                    last_token = 290 as libc::c_int;
                                    return 290 as libc::c_int;
                                }
                                if prev_state == 0 as libc::c_int || prev_state == 1 as libc::c_int
                                {
                                    match *(sudoerslval.string).offset(0 as libc::c_int as isize)
                                        as libc::c_int
                                    {
                                        37 => {
                                            if *(sudoerslval.string)
                                                .offset(1 as libc::c_int as isize)
                                                as libc::c_int
                                                == '\0' as i32
                                                || *(sudoerslval.string)
                                                    .offset(1 as libc::c_int as isize)
                                                    as libc::c_int
                                                    == ':' as i32
                                                    && *(sudoerslval.string)
                                                        .offset(2 as libc::c_int as isize)
                                                        as libc::c_int
                                                        == '\0' as i32
                                            {
                                                if trace_print.is_some() {
                                                    (Some(
                                                        trace_print
                                                            .expect("non-null function pointer"),
                                                    ))
                                                    .expect("non-null function pointer")(
                                                        b"ERROR \0" as *const u8
                                                            as *const libc::c_char,
                                                    );
                                                }
                                                last_token = 290 as libc::c_int;
                                                return 290 as libc::c_int;
                                            }
                                            if trace_print.is_some() {
                                                //                                              (Some(
                                                //                                                    trace_print.expect("non-null function pointer"),
                                                trace_print.expect("non-null function pointer")(
                                                    //.expect("non-null function pointer")(
                                                    b"USERGROUP \0" as *const u8
                                                        as *const libc::c_char,
                                                );
                                            }
                                            last_token = 262 as libc::c_int;
                                            return 262 as libc::c_int;
                                        }
                                        43 => {
                                            if *(sudoerslval.string)
                                                .offset(1 as libc::c_int as isize)
                                                as libc::c_int
                                                == '\0' as i32
                                            {
                                                if trace_print.is_some() {
                                                    (Some(
                                                        trace_print
                                                            .expect("non-null function pointer"),
                                                    ))
                                                    .expect("non-null function pointer")(
                                                        b"ERROR \0" as *const u8
                                                            as *const libc::c_char,
                                                    );
                                                }
                                                last_token = 290 as libc::c_int;
                                                return 290 as libc::c_int;
                                            }
                                            if trace_print.is_some() {
                                                (Some(
                                                    trace_print.expect("non-null function pointer"),
                                                ))
                                                .expect("non-null function pointer")(
                                                    b"NETGROUP \0" as *const u8
                                                        as *const libc::c_char,
                                                );
                                            }
                                            last_token = 261 as libc::c_int;
                                            return 261 as libc::c_int;
                                        }
                                        _ => {}
                                    }
                                }
                                if trace_print.is_some() {
                                    //(Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"WORD(4) \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 263 as libc::c_int;
                                return 263 as libc::c_int;
                            }
                            12 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //(Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"BACKSLASH \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                if !append(sudoerstext, sudoersleng) {
                                    return 0 as libc::c_int;
                                }
                                continue 's_65;
                            }
                            13 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                   (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //                                     .expect("non-null function pointer")(
                                        b"STRBODY \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                if !append(sudoerstext, sudoersleng) {
                                    return 0 as libc::c_int;
                                }
                                continue 's_65;
                            }
                            14 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                 (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //                                       .expect("non-null function pointer")(
                                        b"QUOTEDCHAR \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                if !fill_args(
                                    sudoerstext,
                                    2 as libc::c_int as size_t,
                                    sawspace as libc::c_int,
                                ) {
                                    return 0 as libc::c_int;
                                }
                                sawspace = 0 as libc::c_int != 0;
                                continue 's_65;
                            }
                            15 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"QUOTEDCHAR \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                if !fill_args(
                                    sudoerstext.offset(1 as libc::c_int as isize),
                                    1 as libc::c_int as size_t,
                                    sawspace as libc::c_int,
                                ) {
                                    return 0 as libc::c_int;
                                }
                                sawspace = 0 as libc::c_int != 0;
                                continue 's_65;
                            }
                            16 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                yy_start = 1 as libc::c_int + 2 as libc::c_int * 0 as libc::c_int;
                                let mut yyless_macro_arg: libc::c_int = 0 as libc::c_int;
                                *yy_cp = yy_hold_char;
                                yy_cp = yy_bp
                                    .offset(yyless_macro_arg as isize)
                                    .offset(-(0 as libc::c_int as isize));
                                yy_c_buf_p = yy_cp;
                                sudoerstext = yy_bp;
                                sudoersleng = yy_cp.offset_from(yy_bp) as libc::c_long as size_t;
                                yy_hold_char = *yy_cp;
                                *yy_cp = '\0' as i32 as libc::c_char;
                                yy_c_buf_p = yy_cp;
                                last_token = 257 as libc::c_int;
                                return 257 as libc::c_int;
                            }
                            17 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //(Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"ARG \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                if !fill_args(sudoerstext, sudoersleng, sawspace as libc::c_int) {
                                    return 0 as libc::c_int;
                                }
                                sawspace = 0 as libc::c_int != 0;
                                continue 's_65;
                            }
                            18 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                let mut digest_len: yy_size_t =
                                    sudo_digest_getlen_v1(digest_type) as yy_size_t;
                                if sudoersleng
                                    == digest_len.wrapping_mul(2 as libc::c_int as libc::c_ulong)
                                {
                                    if !fill_txt(
                                        sudoerstext,
                                        sudoersleng,
                                        0 as libc::c_int as size_t,
                                    ) {
                                        return 0 as libc::c_int;
                                    }
                                    yy_start =
                                        1 as libc::c_int + 2 as libc::c_int * 0 as libc::c_int;
                                    if trace_print.is_some() {
                                        //(Some(trace_print.expect("non-null function pointer")))
                                        trace_print.expect("non-null function pointer")(
                                            //.expect("non-null function pointer")(
                                            b"DIGEST \0" as *const u8 as *const libc::c_char,
                                        );
                                    }
                                    last_token = 264 as libc::c_int;
                                    return 264 as libc::c_int;
                                }
                                yy_start = 1 as libc::c_int + 2 as libc::c_int * 0 as libc::c_int;
                                let mut yyless_macro_arg_0: libc::c_int =
                                    sudoersleng as libc::c_int;
                                *yy_cp = yy_hold_char;
                                yy_cp = yy_bp
                                    .offset(yyless_macro_arg_0 as isize)
                                    .offset(-(0 as libc::c_int as isize));
                                yy_c_buf_p = yy_cp;
                                sudoerstext = yy_bp;
                                sudoersleng = yy_cp.offset_from(yy_bp) as libc::c_long as size_t;
                                yy_hold_char = *yy_cp;
                                *yy_cp = '\0' as i32 as libc::c_char;
                                yy_c_buf_p = yy_cp;
                                continue 's_65;
                            }
                            19 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                let mut len: yy_size_t = 0;
                                let mut digest_len_0: yy_size_t =
                                    sudo_digest_getlen_v1(digest_type) as yy_size_t;
                                if *sudoerstext.offset(
                                    sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                        as isize,
                                ) as libc::c_int
                                    == '=' as i32
                                {
                                    len = (4 as libc::c_int as libc::c_ulong).wrapping_mul(
                                        digest_len_0
                                            .wrapping_add(2 as libc::c_int as libc::c_ulong)
                                            .wrapping_div(3 as libc::c_int as libc::c_ulong),
                                    );
                                } else {
                                    len = (4 as libc::c_int as libc::c_ulong)
                                        .wrapping_mul(digest_len_0)
                                        .wrapping_add(2 as libc::c_int as libc::c_ulong)
                                        .wrapping_div(3 as libc::c_int as libc::c_ulong);
                                }
                                if sudoersleng == len {
                                    if !fill_txt(
                                        sudoerstext,
                                        sudoersleng,
                                        0 as libc::c_int as size_t,
                                    ) {
                                        return 0 as libc::c_int;
                                    }
                                    yy_start =
                                        1 as libc::c_int + 2 as libc::c_int * 0 as libc::c_int;
                                    if trace_print.is_some() {
                                        //(Some(trace_print.expect("non-null function pointer")))
                                        trace_print.expect("non-null function pointer")(
                                            //.expect("non-null function pointer")(
                                            b"DIGEST \0" as *const u8 as *const libc::c_char,
                                        );
                                    }
                                    last_token = 264 as libc::c_int;
                                    return 264 as libc::c_int;
                                }
                                yy_start = 1 as libc::c_int + 2 as libc::c_int * 0 as libc::c_int;
                                let mut yyless_macro_arg_1: libc::c_int =
                                    sudoersleng as libc::c_int;
                                *yy_cp = yy_hold_char;
                                yy_cp = yy_bp
                                    .offset(yyless_macro_arg_1 as isize)
                                    .offset(-(0 as libc::c_int as isize));
                                yy_c_buf_p = yy_cp;
                                sudoerstext = yy_bp;
                                sudoersleng = yy_cp.offset_from(yy_bp) as libc::c_long as size_t;
                                yy_hold_char = *yy_cp;
                                *yy_cp = '\0' as i32 as libc::c_char;
                                yy_c_buf_p = yy_cp;
                                continue 's_65;
                            }
                            20 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                let mut path: *mut libc::c_char =
                                    std::ptr::null_mut::<libc::c_char>();
                                if continued {
                                    if trace_print.is_some() {
                                        //(Some(trace_print.expect("non-null function pointer")))
                                        trace_print.expect("non-null function pointer")(
                                            // .expect("non-null function pointer")(
                                            b"ERROR \0" as *const u8 as *const libc::c_char,
                                        );
                                    }
                                    last_token = 290 as libc::c_int;
                                    return 290 as libc::c_int;
                                }
                                path = parse_include_int(sudoerstext, 0 as libc::c_int != 0);
                                if path.is_null() {
                                    return 0 as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //(Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"INCLUDE\n\0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                if !push_include_int(path, 0 as libc::c_int != 0) {
                                    return 0 as libc::c_int;
                                }
                                continue 's_65;
                            }
                            21 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                let mut path_0: *mut libc::c_char =
                                    std::ptr::null_mut::<libc::c_char>();
                                if continued {
                                    if trace_print.is_some() {
                                        //(Some(trace_print.expect("non-null function pointer")))
                                        trace_print.expect("non-null function pointer")(
                                            //.expect("non-null function pointer")(
                                            b"ERROR \0" as *const u8 as *const libc::c_char,
                                        );
                                    }
                                    last_token = 290 as libc::c_int;
                                    return 290 as libc::c_int;
                                }
                                path_0 = parse_include_int(sudoerstext, 1 as libc::c_int != 0);
                                if path_0.is_null() {
                                    return 0 as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //(Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"INCLUDEDIR\n\0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                if !push_include_int(path_0, 1 as libc::c_int != 0) {
                                    return 0 as libc::c_int;
                                }
                                continue 's_65;
                            }
                            22 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                let mut deftype: libc::c_char = 0;
                                let mut n: libc::c_int = 0;
                                if continued {
                                    if trace_print.is_some() {
                                        // (Some(trace_print.expect("non-null function pointer")))
                                        trace_print.expect("non-null function pointer")(
                                            //.expect("non-null function pointer")(
                                            b"ERROR \0" as *const u8 as *const libc::c_char,
                                        );
                                    }
                                    last_token = 290 as libc::c_int;
                                    return 290 as libc::c_int;
                                }
                                n = 0 as libc::c_int;
                                while *(*__ctype_b_loc())
                                    .offset(*sudoerstext.offset(n as isize) as libc::c_uchar
                                        as libc::c_int
                                        as isize)
                                    as libc::c_int
                                    & _ISblank as libc::c_int as libc::c_ushort as libc::c_int
                                    != 0
                                {
                                    n += 1;
                                }
                                n = (n as libc::c_ulong).wrapping_add(
                                    (::core::mem::size_of::<[libc::c_char; 9]>() as libc::c_ulong)
                                        .wrapping_sub(1 as libc::c_int as libc::c_ulong),
                                ) as libc::c_int as libc::c_int;
                                let fresh12 = n;
                                n += 1;
                                deftype = *sudoerstext.offset(fresh12 as isize);
                                if deftype as libc::c_int != '\0' as i32 {
                                    while *(*__ctype_b_loc()).offset(
                                        *sudoerstext.offset(n as isize) as libc::c_uchar
                                            as libc::c_int
                                            as isize,
                                    ) as libc::c_int
                                        & _ISblank as libc::c_int as libc::c_ushort as libc::c_int
                                        != 0
                                    {
                                        n += 1;
                                    }
                                }
                                yy_start = 1 as libc::c_int + 2 as libc::c_int * 1 as libc::c_int;
                                match deftype as libc::c_int {
                                    58 => {
                                        let mut yyless_macro_arg_2: libc::c_int = n;
                                        *yy_cp = yy_hold_char;
                                        yy_cp = yy_bp
                                            .offset(yyless_macro_arg_2 as isize)
                                            .offset(-(0 as libc::c_int as isize));
                                        yy_c_buf_p = yy_cp;
                                        sudoerstext = yy_bp;
                                        sudoersleng =
                                            yy_cp.offset_from(yy_bp) as libc::c_long as size_t;
                                        yy_hold_char = *yy_cp;
                                        *yy_cp = '\0' as i32 as libc::c_char;
                                        yy_c_buf_p = yy_cp;
                                        if trace_print.is_some() {
                                            //                                            (Some(trace_print.expect("non-null function pointer")))
                                            trace_print.expect("non-null function pointer")(
                                                //.expect("non-null function pointer")(
                                                b"DEFAULTS_USER \0" as *const u8
                                                    as *const libc::c_char,
                                            );
                                        }
                                        last_token = 267 as libc::c_int;
                                        return 267 as libc::c_int;
                                    }
                                    62 => {
                                        let mut yyless_macro_arg_3: libc::c_int = n;
                                        *yy_cp = yy_hold_char;
                                        yy_cp = yy_bp
                                            .offset(yyless_macro_arg_3 as isize)
                                            .offset(-(0 as libc::c_int as isize));
                                        yy_c_buf_p = yy_cp;
                                        sudoerstext = yy_bp;
                                        sudoersleng =
                                            yy_cp.offset_from(yy_bp) as libc::c_long as size_t;
                                        yy_hold_char = *yy_cp;
                                        *yy_cp = '\0' as i32 as libc::c_char;
                                        yy_c_buf_p = yy_cp;
                                        if trace_print.is_some() {
                                            //(Some(trace_print.expect("non-null function pointer")))
                                            trace_print.expect("non-null function pointer")(
                                                //.expect("non-null function pointer")(
                                                b"DEFAULTS_RUNAS \0" as *const u8
                                                    as *const libc::c_char,
                                            );
                                        }
                                        last_token = 268 as libc::c_int;
                                        return 268 as libc::c_int;
                                    }
                                    64 => {
                                        let mut yyless_macro_arg_4: libc::c_int = n;
                                        *yy_cp = yy_hold_char;
                                        yy_cp = yy_bp
                                            .offset(yyless_macro_arg_4 as isize)
                                            .offset(-(0 as libc::c_int as isize));
                                        yy_c_buf_p = yy_cp;
                                        sudoerstext = yy_bp;
                                        sudoersleng =
                                            yy_cp.offset_from(yy_bp) as libc::c_long as size_t;
                                        yy_hold_char = *yy_cp;
                                        *yy_cp = '\0' as i32 as libc::c_char;
                                        yy_c_buf_p = yy_cp;
                                        if trace_print.is_some() {
                                            //                                            (Some(trace_print.expect("non-null function pointer")))
                                            trace_print.expect("non-null function pointer")(
                                                //.expect("non-null function pointer")(
                                                b"DEFAULTS_HOST \0" as *const u8
                                                    as *const libc::c_char,
                                            );
                                        }
                                        last_token = 266 as libc::c_int;
                                        return 266 as libc::c_int;
                                    }
                                    33 => {
                                        let mut yyless_macro_arg_5: libc::c_int = n;
                                        *yy_cp = yy_hold_char;
                                        yy_cp = yy_bp
                                            .offset(yyless_macro_arg_5 as isize)
                                            .offset(-(0 as libc::c_int as isize));
                                        yy_c_buf_p = yy_cp;
                                        sudoerstext = yy_bp;
                                        sudoersleng =
                                            yy_cp.offset_from(yy_bp) as libc::c_long as size_t;
                                        yy_hold_char = *yy_cp;
                                        *yy_cp = '\0' as i32 as libc::c_char;
                                        yy_c_buf_p = yy_cp;
                                        if trace_print.is_some() {
                                            // (Some(trace_print.expect("non-null function pointer")))
                                            trace_print.expect("non-null function pointer")(
                                                //.expect("non-null function pointer")(
                                                b"DEFAULTS_CMND \0" as *const u8
                                                    as *const libc::c_char,
                                            );
                                        }
                                        last_token = 269 as libc::c_int;
                                        return 269 as libc::c_int;
                                    }
                                    _ => {
                                        if trace_print.is_some() {
                                            //                                            (Some(trace_print.expect("non-null function pointer")))
                                            trace_print.expect("non-null function pointer")(
                                                //.expect("non-null function pointer")(
                                                b"DEFAULTS \0" as *const u8 as *const libc::c_char,
                                            );
                                        }
                                        last_token = 265 as libc::c_int;
                                        return 265 as libc::c_int;
                                    }
                                }
                            }
                            23 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                let mut n_0: libc::c_int = 0;
                                if continued {
                                    if trace_print.is_some() {
                                        // (Some(trace_print.expect("non-null function pointer")))
                                        trace_print.expect("non-null function pointer")(
                                            //.expect("non-null function pointer")(
                                            b"ERROR \0" as *const u8 as *const libc::c_char,
                                        );
                                    }
                                    last_token = 290 as libc::c_int;
                                    return 290 as libc::c_int;
                                }
                                n_0 = 0 as libc::c_int;
                                while *(*__ctype_b_loc())
                                    .offset(*sudoerstext.offset(n_0 as isize) as libc::c_uchar
                                        as libc::c_int
                                        as isize)
                                    as libc::c_int
                                    & _ISblank as libc::c_int as libc::c_ushort as libc::c_int
                                    != 0
                                {
                                    n_0 += 1;
                                }
                                match *sudoerstext.offset(n_0 as isize) as libc::c_int {
                                    72 => {
                                        if trace_print.is_some() {
                                            //                                            (Some(trace_print.expect("non-null function pointer")))
                                            trace_print.expect("non-null function pointer")(
                                                //.expect("non-null function pointer")(
                                                b"HOSTALIAS \0" as *const u8 as *const libc::c_char,
                                            );
                                        }
                                        last_token = 286 as libc::c_int;
                                        return 286 as libc::c_int;
                                    }
                                    67 => {
                                        if trace_print.is_some() {
                                            //                                            (Some(trace_print.expect("non-null function pointer")))
                                            trace_print.expect("non-null function pointer")(
                                                //.expect("non-null function pointer")(
                                                b"CMNDALIAS \0" as *const u8 as *const libc::c_char,
                                            );
                                        }
                                        last_token = 287 as libc::c_int;
                                        return 287 as libc::c_int;
                                    }
                                    85 => {
                                        if trace_print.is_some() {
                                            // (Some(trace_print.expect("non-null function pointer")))
                                            trace_print.expect("non-null function pointer")(
                                                //.expect("non-null function pointer")(
                                                b"USERALIAS \0" as *const u8 as *const libc::c_char,
                                            );
                                        }
                                        last_token = 288 as libc::c_int;
                                        return 288 as libc::c_int;
                                    }
                                    82 => {
                                        if trace_print.is_some() {
                                            //                                            (Some(trace_print.expect("non-null function pointer")))
                                            trace_print.expect("non-null function pointer")(
                                                //.expect("non-null function pointer")(
                                                b"RUNASALIAS \0" as *const u8
                                                    as *const libc::c_char,
                                            );
                                        }
                                        last_token = 289 as libc::c_int;
                                        return 289 as libc::c_int;
                                    }
                                    _ => {}
                                }
                                continue 's_65;
                            }
                            24 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                    (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"NOPASSWD \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 270 as libc::c_int;
                                return 270 as libc::c_int;
                            }
                            25 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                    (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"PASSWD \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 271 as libc::c_int;
                                return 271 as libc::c_int;
                            }
                            26 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                    (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"NOEXEC \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 272 as libc::c_int;
                                return 272 as libc::c_int;
                            }
                            27 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                    (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"EXEC \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 273 as libc::c_int;
                                return 273 as libc::c_int;
                            }
                            28 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                    (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"SETENV \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 274 as libc::c_int;
                                return 274 as libc::c_int;
                            }
                            29 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                    (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"NOSETENV \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 275 as libc::c_int;
                                return 275 as libc::c_int;
                            }
                            30 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //(Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"LOG_OUTPUT \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 278 as libc::c_int;
                                return 278 as libc::c_int;
                            }
                            31 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //  (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"NOLOG_OUTPUT \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 279 as libc::c_int;
                                return 279 as libc::c_int;
                            }
                            32 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"LOG_INPUT \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 276 as libc::c_int;
                                return 276 as libc::c_int;
                            }
                            33 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                    (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"NOLOG_INPUT \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 277 as libc::c_int;
                                return 277 as libc::c_int;
                            }
                            34 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                    (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //                                      .expect("non-null function pointer")(
                                        b"MAIL \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 280 as libc::c_int;
                                return 280 as libc::c_int;
                            }
                            35 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                    (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"NOMAIL \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 281 as libc::c_int;
                                return 281 as libc::c_int;
                            }
                            36 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                    (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"FOLLOW \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 282 as libc::c_int;
                                return 282 as libc::c_int;
                            }
                            37 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                    (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"NOFOLLOW \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 283 as libc::c_int;
                                return 283 as libc::c_int;
                            }
                            38 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                    (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"ERROR \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 290 as libc::c_int;
                                return 290 as libc::c_int;
                            }
                            39 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if !fill_txt(sudoerstext, sudoersleng, 0 as libc::c_int as size_t) {
                                    return 0 as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"NETGROUP \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 261 as libc::c_int;
                                return 261 as libc::c_int;
                            }
                            40 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if !fill_txt(sudoerstext, sudoersleng, 0 as libc::c_int as size_t) {
                                    return 0 as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"USERGROUP \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 262 as libc::c_int;
                                return 262 as libc::c_int;
                            }
                            41 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if !fill_txt(sudoerstext, sudoersleng, 0 as libc::c_int as size_t) {
                                    return 0 as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"NTWKADDR \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 260 as libc::c_int;
                                return 260 as libc::c_int;
                            }
                            42 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if !fill_txt(sudoerstext, sudoersleng, 0 as libc::c_int as size_t) {
                                    return 0 as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"NTWKADDR \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 260 as libc::c_int;
                                return 260 as libc::c_int;
                            }
                            43 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if !ipv6_valid(sudoerstext) {
                                    if trace_print.is_some() {
                                        //  (Some(trace_print.expect("non-null function pointer")))
                                        trace_print.expect("non-null function pointer")(
                                            //   .expect("non-null function pointer")(
                                            b"ERROR \0" as *const u8 as *const libc::c_char,
                                        );
                                    }
                                    last_token = 290 as libc::c_int;
                                    return 290 as libc::c_int;
                                }
                                if !fill_txt(sudoerstext, sudoersleng, 0 as libc::c_int as size_t) {
                                    return 0 as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"NTWKADDR \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 260 as libc::c_int;
                                return 260 as libc::c_int;
                            }
                            44 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if !ipv6_valid(sudoerstext) {
                                    if trace_print.is_some() {
                                        // (Some(trace_print.expect("non-null function pointer")))
                                        trace_print.expect("non-null function pointer")(
                                            // .expect("non-null function pointer")(
                                            b"ERROR \0" as *const u8 as *const libc::c_char,
                                        );
                                    }
                                    last_token = 290 as libc::c_int;
                                    return 290 as libc::c_int;
                                }
                                if !fill_txt(sudoerstext, sudoersleng, 0 as libc::c_int as size_t) {
                                    return 0 as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"NTWKADDR \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 260 as libc::c_int;
                                return 260 as libc::c_int;
                            }
                            45 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //  .expect("non-null function pointer")(
                                        b"ALL \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 284 as libc::c_int;
                                return 284 as libc::c_int;
                            }
                            46 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"CMND_TIMEOUT \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 295 as libc::c_int;
                                return 295 as libc::c_int;
                            }
                            47 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //(Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"NOTBEFORE \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 296 as libc::c_int;
                                return 296 as libc::c_int;
                            }
                            48 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //  .expect("non-null function pointer")(
                                        b"NOTAFTER \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 297 as libc::c_int;
                                return 297 as libc::c_int;
                            }
                            49 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //  (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //  .expect("non-null function pointer")(
                                        b"ROLE \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 292 as libc::c_int;
                                return 292 as libc::c_int;
                            }
                            50 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"TYPE \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 291 as libc::c_int;
                                return 291 as libc::c_int;
                            }
                            51 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                break '_yy_match;
                            }
                            52 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                break '_yy_match;
                            }
                            53 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                break '_yy_match;
                            }
                            54 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if !fill_cmnd(sudoerstext, sudoersleng) {
                                    return 0 as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"COMMAND \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 257 as libc::c_int;
                                return 257 as libc::c_int;
                            }
                            55 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                digest_type = 0 as libc::c_int;
                                yy_start = 1 as libc::c_int + 2 as libc::c_int * 6 as libc::c_int;
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //  .expect("non-null function pointer")(
                                        b"SHA224_TOK \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 299 as libc::c_int;
                                return 299 as libc::c_int;
                            }
                            56 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                digest_type = 1 as libc::c_int;
                                yy_start = 1 as libc::c_int + 2 as libc::c_int * 6 as libc::c_int;
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"SHA256_TOK \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 300 as libc::c_int;
                                return 300 as libc::c_int;
                            }
                            57 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                digest_type = 2 as libc::c_int;
                                yy_start = 1 as libc::c_int + 2 as libc::c_int * 6 as libc::c_int;
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"SHA384_TOK \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 301 as libc::c_int;
                                return 301 as libc::c_int;
                            }
                            58 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                digest_type = 3 as libc::c_int;
                                yy_start = 1 as libc::c_int + 2 as libc::c_int * 6 as libc::c_int;
                                if trace_print.is_some() {
                                    //  (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"SHA512_TOK \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 302 as libc::c_int;
                                return 302 as libc::c_int;
                            }
                            59 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                yy_start = 1 as libc::c_int + 2 as libc::c_int * 2 as libc::c_int;
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"COMMAND \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                if !fill_cmnd(sudoerstext, sudoersleng) {
                                    return 0 as libc::c_int;
                                }
                                continue 's_65;
                            }
                            60 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if *sudoerstext.offset(
                                    sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                        as isize,
                                ) as libc::c_int
                                    == '/' as i32
                                {
                                    if trace_print.is_some() {
                                        // (Some(trace_print.expect("non-null function pointer")))
                                        trace_print.expect("non-null function pointer")(
                                            // .expect("non-null function pointer")(
                                            b"COMMAND \0" as *const u8 as *const libc::c_char,
                                        );
                                    }
                                    if !fill_cmnd(sudoerstext, sudoersleng) {
                                        return 0 as libc::c_int;
                                    }
                                    last_token = 257 as libc::c_int;
                                    return 257 as libc::c_int;
                                } else {
                                    yy_start =
                                        1 as libc::c_int + 2 as libc::c_int * 2 as libc::c_int;
                                    if trace_print.is_some() {
                                        // (Some(trace_print.expect("non-null function pointer")))
                                        trace_print.expect("non-null function pointer")(
                                            // .expect("non-null function pointer")(
                                            b"COMMAND \0" as *const u8 as *const libc::c_char,
                                        );
                                    }
                                    if !fill_cmnd(sudoerstext, sudoersleng) {
                                        return 0 as libc::c_int;
                                    }
                                }
                                continue 's_65;
                            }
                            61 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //(Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"BEGINSTR \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                sudoerslval.string = std::ptr::null_mut::<libc::c_char>();
                                prev_state = (yy_start - 1 as libc::c_int) / 2 as libc::c_int;
                                yy_start = 1 as libc::c_int + 2 as libc::c_int * 5 as libc::c_int;
                                continue 's_65;
                            }
                            62 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if !fill_txt(sudoerstext, sudoersleng, 0 as libc::c_int as size_t) {
                                    return 0 as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"WORD(5) \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 263 as libc::c_int;
                                return 263 as libc::c_int;
                            }
                            63 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //  (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"( \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = '(' as i32;
                                return '(' as i32;
                            }
                            64 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b") \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = ')' as i32;
                                return ')' as i32;
                            }
                            65 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b", \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = ',' as i32;
                                return ',' as i32;
                            }
                            66 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //   (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"= \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = '=' as i32;
                                return '=' as i32;
                            }
                            67 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //                                  (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //                                        .expect("non-null function pointer")(
                                        b": \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = ':' as i32;
                                return ':' as i32;
                            }
                            68 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if sudoersleng & 1 as libc::c_int as libc::c_ulong != 0 {
                                    if trace_print.is_some() {
                                        // (Some(trace_print.expect("non-null function pointer")))
                                        trace_print.expect("non-null function pointer")(
                                            // .expect("non-null function pointer")(
                                            b"!\0" as *const u8 as *const libc::c_char,
                                        );
                                    }
                                    last_token = '!' as i32;
                                    return '!' as i32;
                                }
                                continue 's_65;
                            }
                            69 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if (yy_start - 1 as libc::c_int) / 2 as libc::c_int
                                    == 5 as libc::c_int
                                {
                                    if trace_print.is_some() {
                                        //(Some(trace_print.expect("non-null function pointer")))
                                        trace_print.expect("non-null function pointer")(
                                            //.expect("non-null function pointer")(
                                            b"ERROR \0" as *const u8 as *const libc::c_char,
                                        );
                                    }
                                    last_token = 290 as libc::c_int;
                                    return 290 as libc::c_int;
                                }
                                yy_start = 1 as libc::c_int + 2 as libc::c_int * 0 as libc::c_int;
                                sudolineno += 1;
                                continued = 0 as libc::c_int != 0;
                                if trace_print.is_some() {
                                    // (Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        // .expect("non-null function pointer")(
                                        b"\n\0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 285 as libc::c_int;
                                return 285 as libc::c_int;
                            }
                            70 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                sawspace = 1 as libc::c_int != 0;
                                continue 's_65;
                            }
                            71 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                sawspace = 1 as libc::c_int != 0;
                                sudolineno += 1;
                                continued = 1 as libc::c_int != 0;
                                continue 's_65;
                            }
                            72 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if *sudoerstext.offset(
                                    sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                        as isize,
                                ) as libc::c_int
                                    == '\n' as i32
                                {
                                    yy_start =
                                        1 as libc::c_int + 2 as libc::c_int * 0 as libc::c_int;
                                    sudolineno += 1;
                                    continued = 0 as libc::c_int != 0;
                                } else if feof(sudoersin) == 0 {
                                    if trace_print.is_some() {
                                        //  (Some(trace_print.expect("non-null function pointer")))
                                        trace_print.expect("non-null function pointer")(
                                            // .expect("non-null function pointer")(
                                            b"ERROR \0" as *const u8 as *const libc::c_char,
                                        );
                                    }
                                    last_token = 290 as libc::c_int;
                                    return 290 as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //(Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"#\n\0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 285 as libc::c_int;
                                return 285 as libc::c_int;
                            }
                            73 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                if trace_print.is_some() {
                                    //(Some(trace_print.expect("non-null function pointer")))
                                    trace_print.expect("non-null function pointer")(
                                        //.expect("non-null function pointer")(
                                        b"ERROR \0" as *const u8 as *const libc::c_char,
                                    );
                                }
                                last_token = 290 as libc::c_int;
                                return 290 as libc::c_int;
                            }
                            //76 | 77 | 78 | 79 | 80 | 81 | 82 => {
                            76..=82 => {
                                if (yy_start - 1 as libc::c_int) / 2 as libc::c_int
                                    != 0 as libc::c_int
                                {
                                    yy_start =
                                        1 as libc::c_int + 2 as libc::c_int * 0 as libc::c_int;
                                    if trace_print.is_some() {
                                        //(Some(trace_print.expect("non-null function pointer")))
                                        trace_print.expect("non-null function pointer")(
                                            //  .expect("non-null function pointer")(
                                            b"ERROR \0" as *const u8 as *const libc::c_char,
                                        );
                                    }
                                    last_token = 290 as libc::c_int;
                                    return 290 as libc::c_int;
                                }
                                if !pop_include() {
                                    return 0 as libc::c_int;
                                }
                                continue 's_65;
                            }
                            74 => {
                                if sudoersleng > 0 as libc::c_int as libc::c_ulong {
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_at_bol = (*sudoerstext.offset(
                                        sudoersleng.wrapping_sub(1 as libc::c_int as libc::c_ulong)
                                            as isize,
                                    )
                                        as libc::c_int
                                        == '\n' as i32)
                                        as libc::c_int;
                                }
                                let mut y: libc::c_ulong = fwrite(
                                    sudoerstext as *const libc::c_void,
                                    sudoersleng,
                                    1 as libc::c_int as libc::c_ulong,
                                    sudoersout,
                                );
                                continue 's_65;
                            }
                            75 => {
                                yy_amount_of_matched_text =
                                    yy_cp.offset_from(sudoerstext) as libc::c_long as libc::c_int
                                        - 1 as libc::c_int;
                                *yy_cp = yy_hold_char;
                                if (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                    .yy_buffer_status
                                    == 0 as libc::c_int
                                {
                                    yy_n_chars = (**yy_buffer_stack
                                        .offset(yy_buffer_stack_top as isize))
                                    .yy_n_chars;
                                    let fresh13 = &mut (**yy_buffer_stack
                                        .offset(yy_buffer_stack_top as isize))
                                    .yy_input_file;
                                    *fresh13 = sudoersin;
                                    (**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                                        .yy_buffer_status = 1 as libc::c_int;
                                }
                                if yy_c_buf_p
                                    <= &mut *((**yy_buffer_stack
                                        .offset(yy_buffer_stack_top as isize))
                                    .yy_ch_buf)
                                        .offset(yy_n_chars as isize)
                                        as *mut libc::c_char
                                {
                                    yy_next_state = 0;
                                    yy_c_buf_p =
                                        sudoerstext.offset(yy_amount_of_matched_text as isize);
                                    yy_current_state = yy_get_previous_state();
                                    yy_next_state = yy_try_NUL_trans(yy_current_state);
                                    yy_bp = sudoerstext.offset(0 as libc::c_int as isize);
                                    if yy_next_state != 0 {
                                        current_block = 13675385353954805170;
                                        break;
                                    } else {
                                        current_block = 174457820851122527;
                                        break;
                                    }
                                } else {
                                    match yy_get_next_buffer() {
                                        1 => {
                                            yy_did_buffer_switch_on_eof = 0 as libc::c_int;
                                            yy_c_buf_p =
                                                sudoerstext.offset(0 as libc::c_int as isize);
                                            yy_act = 75 as libc::c_int
                                                + (yy_start - 1 as libc::c_int) / 2 as libc::c_int
                                                + 1 as libc::c_int;
                                        }
                                        0 => {
                                            yy_c_buf_p = sudoerstext
                                                .offset(yy_amount_of_matched_text as isize);
                                            yy_current_state = yy_get_previous_state();
                                            yy_cp = yy_c_buf_p;
                                            yy_bp = sudoerstext.offset(0 as libc::c_int as isize);
                                            break '_yy_find_action;
                                        }
                                        2 => {
                                            yy_c_buf_p = &mut *((**yy_buffer_stack
                                                .offset(yy_buffer_stack_top as isize))
                                            .yy_ch_buf)
                                                .offset(yy_n_chars as isize)
                                                as *mut libc::c_char;
                                            yy_current_state = yy_get_previous_state();
                                            yy_cp = yy_c_buf_p;
                                            yy_bp = sudoerstext.offset(0 as libc::c_int as isize);
                                            continue '_yy_find_action;
                                        }
                                        _ => {
                                            continue 's_65;
                                        }
                                    }
                                }
                            }
                            _ => {
                                yy_fatal_error(
                                    b"fatal flex scanner internal error--no action found\0"
                                        as *const u8
                                        as *const libc::c_char,
                                );
                                continue 's_65;
                            }
                        }
                    }
                    match current_block {
                        174457820851122527 => {
                            yy_cp = yy_c_buf_p;
                        }
                        _ => {
                            yy_c_buf_p = yy_c_buf_p.offset(1);
                            yy_cp = yy_c_buf_p;
                            yy_current_state = yy_next_state;
                            break;
                        }
                    }
                }
            }
            if !fill_txt(sudoerstext, sudoersleng, 0 as libc::c_int as size_t) {
                return 0 as libc::c_int;
            }
            if trace_print.is_some() {
                //(Some(trace_print.expect("non-null function pointer")))
                trace_print.expect("non-null function pointer")(
                    // .expect("non-null function pointer")(
                    b"ALIAS \0" as *const u8 as *const libc::c_char,
                );
            }
            last_token = 258 as libc::c_int;
            return 258 as libc::c_int;
        }
    }
}
fn yy_get_next_buffer() -> libc::c_int {
    unsafe {
        let mut dest: *mut libc::c_char =
            (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_ch_buf;
        let mut source: *mut libc::c_char = sudoerstext;
        let mut number_to_move: libc::c_int = 0;
        let mut i: libc::c_int = 0;
        let mut ret_val: libc::c_int = 0;
        if yy_c_buf_p
            > &mut *((**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_ch_buf)
                .offset(yy_n_chars.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize)
                as *mut libc::c_char
        {
            yy_fatal_error(
                b"fatal flex scanner internal error--end of buffer missed\0" as *const u8
                    as *const libc::c_char,
            );
        }
        if (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_fill_buffer
            == 0 as libc::c_int
        {
            if yy_c_buf_p.offset_from(sudoerstext) as libc::c_long
                - 0 as libc::c_int as libc::c_long
                == 1 as libc::c_int as libc::c_long
            {
                return 1 as libc::c_int;
            } else {
                return 2 as libc::c_int;
            }
        }
        number_to_move =
            yy_c_buf_p.offset_from(sudoerstext) as libc::c_long as libc::c_int - 1 as libc::c_int;
        i = 0 as libc::c_int;
        while i < number_to_move {
            let fresh14 = source;
            source = source.offset(1);
            let fresh15 = dest;
            dest = dest.offset(1);
            *fresh15 = *fresh14;
            i += 1;
        }
        if (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_buffer_status
            == 2 as libc::c_int
        {
            yy_n_chars = 0 as libc::c_int as yy_size_t;
            (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_n_chars = yy_n_chars;
        } else {
            let mut num_to_read: yy_size_t =
                ((**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_buf_size)
                    .wrapping_sub(number_to_move as libc::c_ulong)
                    .wrapping_sub(1 as libc::c_int as libc::c_ulong);
            while num_to_read <= 0 as libc::c_int as libc::c_ulong {
                let mut b: YY_BUFFER_STATE = *yy_buffer_stack.offset(yy_buffer_stack_top as isize);
                let mut yy_c_buf_p_offset: libc::c_int =
                    yy_c_buf_p.offset_from((*b).yy_ch_buf) as libc::c_long as libc::c_int;
                if (*b).yy_is_our_buffer != 0 {
                    let mut new_size: yy_size_t =
                        ((*b).yy_buf_size).wrapping_mul(2 as libc::c_int as libc::c_ulong);
                    if new_size <= 0 as libc::c_int as libc::c_ulong {
                        (*b).yy_buf_size = ((*b).yy_buf_size as libc::c_ulong).wrapping_add(
                            ((*b).yy_buf_size).wrapping_div(8 as libc::c_int as libc::c_ulong),
                        ) as yy_size_t as yy_size_t;
                    } else {
                        (*b).yy_buf_size = ((*b).yy_buf_size as libc::c_ulong)
                            .wrapping_mul(2 as libc::c_int as libc::c_ulong)
                            as yy_size_t as yy_size_t;
                    }
                    (*b).yy_ch_buf = sudoersrealloc(
                        (*b).yy_ch_buf as *mut libc::c_void,
                        ((*b).yy_buf_size).wrapping_add(2 as libc::c_int as libc::c_ulong),
                    ) as *mut libc::c_char;
                } else {
                    (*b).yy_ch_buf = std::ptr::null_mut::<libc::c_char>();
                }
                if ((*b).yy_ch_buf).is_null() {
                    yy_fatal_error(
                        b"fatal error - scanner input buffer overflow\0" as *const u8
                            as *const libc::c_char,
                    );
                }
                yy_c_buf_p =
                    &mut *((*b).yy_ch_buf).offset(yy_c_buf_p_offset as isize) as *mut libc::c_char;
                num_to_read = ((**yy_buffer_stack.offset(yy_buffer_stack_top as isize))
                    .yy_buf_size)
                    .wrapping_sub(number_to_move as libc::c_ulong)
                    .wrapping_sub(1 as libc::c_int as libc::c_ulong);
            }
            if num_to_read > 8192 as libc::c_int as libc::c_ulong {
                num_to_read = 8192 as libc::c_int as yy_size_t;
            }
            if (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_is_interactive != 0 {
                let mut c: libc::c_int = '*' as i32;
                let mut n: size_t = 0;
                n = 0 as libc::c_int as size_t;
                while n < num_to_read
                    && {
                        c = getc(sudoersin);
                        c != -(1 as libc::c_int)
                    }
                    && c != '\n' as i32
                {
                    *(&mut *((**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_ch_buf)
                        .offset(number_to_move as isize)
                        as *mut libc::c_char)
                        .offset(n as isize) = c as libc::c_char;
                    n = n.wrapping_add(1);
                }
                if c == '\n' as i32 {
                    let fresh16 = n;
                    n = n.wrapping_add(1);
                    *(&mut *((**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_ch_buf)
                        .offset(number_to_move as isize)
                        as *mut libc::c_char)
                        .offset(fresh16 as isize) = c as libc::c_char;
                }
                if c == -(1 as libc::c_int) && ferror(sudoersin) != 0 {
                    yy_fatal_error(
                        b"input in flex scanner failed\0" as *const u8 as *const libc::c_char,
                    );
                }
                yy_n_chars = n;
            } else {
                *__errno_location() = 0 as libc::c_int;
                loop {
                    yy_n_chars = fread(
                        &mut *((**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_ch_buf)
                            .offset(number_to_move as isize)
                            as *mut libc::c_char as *mut libc::c_void,
                        1 as libc::c_int as libc::c_ulong,
                        num_to_read,
                        sudoersin,
                    );
                    if !(yy_n_chars == 0 as libc::c_int as libc::c_ulong && ferror(sudoersin) != 0)
                    {
                        break;
                    }
                    if *__errno_location() != 4 as libc::c_int {
                        yy_fatal_error(
                            b"input in flex scanner failed\0" as *const u8 as *const libc::c_char,
                        );
                        break;
                    } else {
                        *__errno_location() = 0 as libc::c_int;
                        clearerr(sudoersin);
                    }
                }
            }
            (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_n_chars = yy_n_chars;
        }
        if yy_n_chars == 0 as libc::c_int as libc::c_ulong {
            if number_to_move == 0 as libc::c_int {
                ret_val = 1 as libc::c_int;
                sudoersrestart(sudoersin);
            } else {
                ret_val = 2 as libc::c_int;
                (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_buffer_status =
                    2 as libc::c_int;
            }
        } else {
            ret_val = 0 as libc::c_int;
        }
        if yy_n_chars.wrapping_add(number_to_move as libc::c_ulong)
            > (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_buf_size
        {
            let mut new_size_0: yy_size_t = yy_n_chars
                .wrapping_add(number_to_move as libc::c_ulong)
                .wrapping_add(yy_n_chars >> 1 as libc::c_int);
            let fresh17 = &mut (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_ch_buf;
            *fresh17 = sudoersrealloc(
                (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_ch_buf
                    as *mut libc::c_void,
                new_size_0,
            ) as *mut libc::c_char;
            if ((**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_ch_buf).is_null() {
                yy_fatal_error(
                    b"out of dynamic memory in yy_get_next_buffer()\0" as *const u8
                        as *const libc::c_char,
                );
            }
            (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_buf_size =
                new_size_0.wrapping_sub(2 as libc::c_int as libc::c_ulong) as libc::c_int
                    as yy_size_t;
        }
        yy_n_chars = (yy_n_chars as libc::c_ulong).wrapping_add(number_to_move as libc::c_ulong)
            as yy_size_t as yy_size_t;
        *((**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_ch_buf)
            .offset(yy_n_chars as isize) = 0 as libc::c_int as libc::c_char;
        *((**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_ch_buf)
            .offset(yy_n_chars.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize) =
            0 as libc::c_int as libc::c_char;
        sudoerstext = &mut *((**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_ch_buf)
            .offset(0 as libc::c_int as isize) as *mut libc::c_char;
        ret_val
    }
}
fn yy_get_previous_state() -> yy_state_type {
    let mut yy_current_state: yy_state_type = 0;
    let mut yy_cp: *mut libc::c_char = std::ptr::null_mut::<libc::c_char>();
    unsafe {
        yy_current_state = yy_start;
        yy_current_state += (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_at_bol;
        yy_cp = sudoerstext.offset(0 as libc::c_int as isize);
        while yy_cp < yy_c_buf_p {
            let mut yy_c: YY_CHAR = (if *yy_cp as libc::c_int != 0 {
                yy_ec[*yy_cp as libc::c_uchar as libc::c_uint as usize]
            } else {
                1 as libc::c_int
            }) as YY_CHAR;
            if yy_accept[yy_current_state as usize] != 0 {
                yy_last_accepting_state = yy_current_state;
                yy_last_accepting_cpos = yy_cp;
            }
            while yy_chk
                [(yy_base[yy_current_state as usize] as libc::c_int + yy_c as libc::c_int) as usize]
                as libc::c_int
                != yy_current_state
            {
                yy_current_state = yy_def[yy_current_state as usize] as libc::c_int;
                if yy_current_state >= 896 as libc::c_int {
                    yy_c = yy_meta[yy_c as libc::c_uint as usize] as YY_CHAR;
                }
            }
            yy_current_state = yy_nxt[(yy_base[yy_current_state as usize] as libc::c_uint)
                .wrapping_add(yy_c as libc::c_uint) as usize]
                as yy_state_type;
            yy_cp = yy_cp.offset(1);
        }
    }
    yy_current_state
}
fn yy_try_NUL_trans(mut yy_current_state: yy_state_type) -> yy_state_type {
    let mut yy_is_jam: libc::c_int = 0;
    unsafe {
        let mut yy_cp: *mut libc::c_char = yy_c_buf_p;
        let mut yy_c: YY_CHAR = 1 as libc::c_int as YY_CHAR;
        if yy_accept[yy_current_state as usize] != 0 {
            yy_last_accepting_state = yy_current_state;
            yy_last_accepting_cpos = yy_cp;
        }
        while yy_chk
            [(yy_base[yy_current_state as usize] as libc::c_int + yy_c as libc::c_int) as usize]
            as libc::c_int
            != yy_current_state
        {
            yy_current_state = yy_def[yy_current_state as usize] as libc::c_int;
            if yy_current_state >= 896 as libc::c_int {
                yy_c = yy_meta[yy_c as libc::c_uint as usize] as YY_CHAR;
            }
        }
        yy_current_state = yy_nxt[(yy_base[yy_current_state as usize] as libc::c_uint)
            .wrapping_add(yy_c as libc::c_uint) as usize]
            as yy_state_type;
        yy_is_jam = (yy_current_state == 895 as libc::c_int) as libc::c_int;
    }
    if yy_is_jam != 0 {
        0 as libc::c_int
    } else {
        yy_current_state
    }
}
#[no_mangle]
pub fn sudoersrestart(mut input_file: *mut FILE) {
    unsafe {
        if if !yy_buffer_stack.is_null() {
            *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
        } else {
            0 as YY_BUFFER_STATE
        }
        .is_null()
        {
            sudoersensure_buffer_stack();
            let fresh18 = &mut *yy_buffer_stack.offset(yy_buffer_stack_top as isize);
            *fresh18 = sudoers_create_buffer(sudoersin, 16384 as libc::c_int);
        }
        sudoers_init_buffer(
            if !yy_buffer_stack.is_null() {
                *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
            } else {
                0 as YY_BUFFER_STATE
            },
            input_file,
        );
        sudoers_load_buffer_state()
    };
}
#[no_mangle]
pub fn sudoers_switch_to_buffer(mut new_buffer: YY_BUFFER_STATE) {
    unsafe { sudoersensure_buffer_stack() };
    unsafe {
        if (if !yy_buffer_stack.is_null() {
            *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
        } else {
            0 as YY_BUFFER_STATE
        }) == new_buffer
        {
            return;
        }
        if !if !yy_buffer_stack.is_null() {
            *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
        } else {
            0 as YY_BUFFER_STATE
        }
        .is_null()
        {
            *yy_c_buf_p = yy_hold_char;
            let fresh19 = &mut (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_buf_pos;
            *fresh19 = yy_c_buf_p;
            (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_n_chars = yy_n_chars;
        }
        let fresh20 = &mut *yy_buffer_stack.offset(yy_buffer_stack_top as isize);
        *fresh20 = new_buffer;
        unsafe { sudoers_load_buffer_state() };
        yy_did_buffer_switch_on_eof = 1 as libc::c_int;
    }
}
fn sudoers_load_buffer_state() {
    unsafe {
        yy_n_chars = (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_n_chars;
        yy_c_buf_p = (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_buf_pos;
        sudoerstext = yy_c_buf_p;
        sudoersin = (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_input_file;
        yy_hold_char = *yy_c_buf_p;
    }
}
#[no_mangle]
pub fn sudoers_create_buffer(mut file: *mut FILE, mut size: libc::c_int) -> YY_BUFFER_STATE {
    let mut b: YY_BUFFER_STATE = std::ptr::null_mut::<yy_buffer_state>();
    unsafe {
        b = sudoersalloc(::core::mem::size_of::<yy_buffer_state>() as libc::c_ulong)
            as YY_BUFFER_STATE;
        if b.is_null() {
            yy_fatal_error(
                b"out of dynamic memory in sudoers_create_buffer()\0" as *const u8
                    as *const libc::c_char,
            );
        }
        (*b).yy_buf_size = size as yy_size_t;
        (*b).yy_ch_buf =
            sudoersalloc(((*b).yy_buf_size).wrapping_add(2 as libc::c_int as libc::c_ulong))
                as *mut libc::c_char;
        if ((*b).yy_ch_buf).is_null() {
            yy_fatal_error(
                b"out of dynamic memory in sudoers_create_buffer()\0" as *const u8
                    as *const libc::c_char,
            );
        }
        (*b).yy_is_our_buffer = 1 as libc::c_int;
        sudoers_init_buffer(b, file);
    }
    b
}
#[no_mangle]
pub fn sudoers_delete_buffer(mut b: YY_BUFFER_STATE) {
    if b.is_null() {
        return;
    }
    unsafe {
        if b == (if !yy_buffer_stack.is_null() {
            *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
        } else {
            0 as YY_BUFFER_STATE
        }) {
            let fresh21 = &mut *yy_buffer_stack.offset(yy_buffer_stack_top as isize);
            *fresh21 = 0 as YY_BUFFER_STATE;
        }
        if (*b).yy_is_our_buffer != 0 {
            sudoersfree((*b).yy_ch_buf as *mut libc::c_void);
        }
    }
    unsafe { sudoersfree(b as *mut libc::c_void) };
}
fn sudoers_init_buffer(mut b: YY_BUFFER_STATE, mut file: *mut FILE) {
    unsafe {
        let mut oerrno: libc::c_int = *__errno_location();
        sudoers_flush_buffer(b);
        (*b).yy_input_file = file;
        (*b).yy_fill_buffer = 1 as libc::c_int;
        if b != (if !yy_buffer_stack.is_null() {
            *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
        } else {
            0 as YY_BUFFER_STATE
        }) {
            (*b).yy_bs_lineno = 1 as libc::c_int;
            (*b).yy_bs_column = 0 as libc::c_int;
        }
        (*b).yy_is_interactive = if !file.is_null() {
            (isatty(fileno(file)) > 0 as libc::c_int) as libc::c_int
        } else {
            0 as libc::c_int
        };
        *__errno_location() = oerrno;
    }
}
#[no_mangle]
pub fn sudoers_flush_buffer(mut b: YY_BUFFER_STATE) {
    if b.is_null() {
        return;
    }
    unsafe {
        (*b).yy_n_chars = 0 as libc::c_int as yy_size_t;
        *((*b).yy_ch_buf).offset(0 as libc::c_int as isize) = 0 as libc::c_int as libc::c_char;
        *((*b).yy_ch_buf).offset(1 as libc::c_int as isize) = 0 as libc::c_int as libc::c_char;
        (*b).yy_buf_pos =
            &mut *((*b).yy_ch_buf).offset(0 as libc::c_int as isize) as *mut libc::c_char;
        (*b).yy_at_bol = 1 as libc::c_int;
        (*b).yy_buffer_status = 0 as libc::c_int;
        if b == (if !yy_buffer_stack.is_null() {
            *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
        } else {
            0 as YY_BUFFER_STATE
        }) {
            sudoers_load_buffer_state();
        }
    }
}
#[no_mangle]
pub fn sudoerspush_buffer_state(mut new_buffer: YY_BUFFER_STATE) {
    if new_buffer.is_null() {
        return;
    }
    unsafe {
        sudoersensure_buffer_stack();
        if !if !yy_buffer_stack.is_null() {
            *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
        } else {
            0 as YY_BUFFER_STATE
        }
        .is_null()
        {
            *yy_c_buf_p = yy_hold_char;
            let fresh22 = &mut (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_buf_pos;
            *fresh22 = yy_c_buf_p;
            (**yy_buffer_stack.offset(yy_buffer_stack_top as isize)).yy_n_chars = yy_n_chars;
        }
        if !if !yy_buffer_stack.is_null() {
            *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
        } else {
            0 as YY_BUFFER_STATE
        }
        .is_null()
        {
            yy_buffer_stack_top = yy_buffer_stack_top.wrapping_add(1);
        }
        let fresh23 = &mut *yy_buffer_stack.offset(yy_buffer_stack_top as isize);
        *fresh23 = new_buffer;
        sudoers_load_buffer_state();
        yy_did_buffer_switch_on_eof = 1 as libc::c_int;
    }
}
#[no_mangle]
pub fn sudoerspop_buffer_state() {
    unsafe {
        if if !yy_buffer_stack.is_null() {
            *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
        } else {
            0 as YY_BUFFER_STATE
        }
        .is_null()
        {
            return;
        }
        sudoers_delete_buffer(if !yy_buffer_stack.is_null() {
            *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
        } else {
            0 as YY_BUFFER_STATE
        });
        let fresh24 = &mut *yy_buffer_stack.offset(yy_buffer_stack_top as isize);
        *fresh24 = 0 as YY_BUFFER_STATE;
        if yy_buffer_stack_top > 0 as libc::c_int as libc::c_ulong {
            yy_buffer_stack_top = yy_buffer_stack_top.wrapping_sub(1);
        }
        if !if !yy_buffer_stack.is_null() {
            *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
        } else {
            0 as YY_BUFFER_STATE
        }
        .is_null()
        {
            sudoers_load_buffer_state();
            yy_did_buffer_switch_on_eof = 1 as libc::c_int;
        }
    }
}
fn sudoersensure_buffer_stack() {
    let mut num_to_alloc: yy_size_t = 0;
    unsafe {
        if yy_buffer_stack.is_null() {
            num_to_alloc = 1 as libc::c_int as yy_size_t;
            yy_buffer_stack = sudoersalloc(
                num_to_alloc
                    .wrapping_mul(::core::mem::size_of::<*mut yy_buffer_state>() as libc::c_ulong),
            ) as *mut *mut yy_buffer_state;
            if yy_buffer_stack.is_null() {
                yy_fatal_error(
                    b"out of dynamic memory in sudoersensure_buffer_stack()\0" as *const u8
                        as *const libc::c_char,
                );
            }
            memset(
                yy_buffer_stack as *mut libc::c_void,
                0 as libc::c_int,
                num_to_alloc
                    .wrapping_mul(::core::mem::size_of::<*mut yy_buffer_state>() as libc::c_ulong),
            );
            yy_buffer_stack_max = num_to_alloc;
            yy_buffer_stack_top = 0 as libc::c_int as size_t;
            return;
        }
        if yy_buffer_stack_top
            >= yy_buffer_stack_max.wrapping_sub(1 as libc::c_int as libc::c_ulong)
        {
            let mut grow_size: libc::c_int = 8 as libc::c_int;
            num_to_alloc = yy_buffer_stack_max.wrapping_add(grow_size as libc::c_ulong);
            yy_buffer_stack = sudoersrealloc(
                yy_buffer_stack as *mut libc::c_void,
                num_to_alloc
                    .wrapping_mul(::core::mem::size_of::<*mut yy_buffer_state>() as libc::c_ulong),
            ) as *mut *mut yy_buffer_state;
            if yy_buffer_stack.is_null() {
                yy_fatal_error(
                    b"out of dynamic memory in sudoersensure_buffer_stack()\0" as *const u8
                        as *const libc::c_char,
                );
            }
            memset(
                yy_buffer_stack.offset(yy_buffer_stack_max as isize) as *mut libc::c_void,
                0 as libc::c_int,
                (grow_size as libc::c_ulong)
                    .wrapping_mul(::core::mem::size_of::<*mut yy_buffer_state>() as libc::c_ulong),
            );
        }
        yy_buffer_stack_max = num_to_alloc;
    }
}
#[no_mangle]
pub fn sudoers_scan_buffer(mut base: *mut libc::c_char, mut size: yy_size_t) -> YY_BUFFER_STATE {
    let mut b: YY_BUFFER_STATE = std::ptr::null_mut::<yy_buffer_state>();
    unsafe {
        if size < 2 as libc::c_int as libc::c_ulong
            || *base.offset(size.wrapping_sub(2 as libc::c_int as libc::c_ulong) as isize)
                as libc::c_int
                != 0 as libc::c_int
            || *base.offset(size.wrapping_sub(1 as libc::c_int as libc::c_ulong) as isize)
                as libc::c_int
                != 0 as libc::c_int
        {
            return 0 as YY_BUFFER_STATE;
        }
        b = sudoersalloc(::core::mem::size_of::<yy_buffer_state>() as libc::c_ulong)
            as YY_BUFFER_STATE;
        if b.is_null() {
            yy_fatal_error(
                b"out of dynamic memory in sudoers_scan_buffer()\0" as *const u8
                    as *const libc::c_char,
            );
        }
        (*b).yy_buf_size = size.wrapping_sub(2 as libc::c_int as libc::c_ulong);
        (*b).yy_ch_buf = base;
        (*b).yy_buf_pos = (*b).yy_ch_buf;
        (*b).yy_is_our_buffer = 0 as libc::c_int;
        (*b).yy_input_file = std::ptr::null_mut::<FILE>();
        (*b).yy_n_chars = (*b).yy_buf_size;
        (*b).yy_is_interactive = 0 as libc::c_int;
        (*b).yy_at_bol = 1 as libc::c_int;
        (*b).yy_fill_buffer = 0 as libc::c_int;
        (*b).yy_buffer_status = 0 as libc::c_int;
    }
    sudoers_switch_to_buffer(b);
    b
}
#[no_mangle]
pub fn sudoers_scan_string(mut yystr: *const libc::c_char) -> YY_BUFFER_STATE {
    unsafe { sudoers_scan_bytes(yystr, strlen(yystr)) }
}
#[no_mangle]
pub fn sudoers_scan_bytes(
    mut yybytes: *const libc::c_char,
    mut _yybytes_len: yy_size_t,
) -> YY_BUFFER_STATE {
    let mut b: YY_BUFFER_STATE = std::ptr::null_mut::<yy_buffer_state>();
    let mut buf: *mut libc::c_char = std::ptr::null_mut::<libc::c_char>();
    let mut n: yy_size_t = 0;
    let mut i: yy_size_t = 0;
    n = _yybytes_len.wrapping_add(2 as libc::c_int as libc::c_ulong);
    unsafe {
        buf = sudoersalloc(n) as *mut libc::c_char;
        if buf.is_null() {
            yy_fatal_error(
                b"out of dynamic memory in sudoers_scan_bytes()\0" as *const u8
                    as *const libc::c_char,
            );
        }
        i = 0 as libc::c_int as yy_size_t;
        while i < _yybytes_len {
            *buf.offset(i as isize) = *yybytes.offset(i as isize);
            i = i.wrapping_add(1);
        }
        let fresh25 =
            &mut *buf.offset(_yybytes_len.wrapping_add(1 as libc::c_int as libc::c_ulong) as isize);
        *fresh25 = 0 as libc::c_int as libc::c_char;
        *buf.offset(_yybytes_len as isize) = *fresh25;
        b = sudoers_scan_buffer(buf, n);
        if b.is_null() {
            yy_fatal_error(
                b"bad buffer in sudoers_scan_bytes()\0" as *const u8 as *const libc::c_char,
            );
        }
        (*b).yy_is_our_buffer = 1 as libc::c_int;
    }
    b
}
fn yy_fatal_error(mut msg: *const libc::c_char) {
    unsafe {
        fprintf(stderr, b"%s\n\0" as *const u8 as *const libc::c_char, msg);
        exit(2 as libc::c_int);
    }
}
#[no_mangle]
pub unsafe fn sudoersget_lineno() -> libc::c_int {
    sudoerslineno
}
#[no_mangle]
pub unsafe fn sudoersget_in() -> *mut FILE {
    sudoersin
}
#[no_mangle]
pub unsafe fn sudoersget_out() -> *mut FILE {
    sudoersout
}
#[no_mangle]
pub unsafe fn sudoersget_leng() -> yy_size_t {
    sudoersleng
}
#[no_mangle]
pub unsafe fn sudoersget_text() -> *mut libc::c_char {
    sudoerstext
}
#[no_mangle]
pub unsafe fn sudoersset_lineno(mut line_number: libc::c_int) {
    sudoerslineno = line_number;
}
#[no_mangle]
pub unsafe fn sudoersset_in(mut in_str: *mut FILE) {
    sudoersin = in_str;
}
#[no_mangle]
pub unsafe fn sudoersset_out(mut out_str: *mut FILE) {
    sudoersout = out_str;
}
#[no_mangle]
pub unsafe fn sudoersget_debug() -> libc::c_int {
    sudoers_flex_debug
}
#[no_mangle]
pub unsafe fn sudoersset_debug(mut bdebug: libc::c_int) {
    sudoers_flex_debug = bdebug;
}
unsafe extern "C" fn yy_init_globals() -> libc::c_int {
    yy_buffer_stack = std::ptr::null_mut::<YY_BUFFER_STATE>();
    yy_buffer_stack_top = 0 as libc::c_int as size_t;
    yy_buffer_stack_max = 0 as libc::c_int as size_t;
    yy_c_buf_p = std::ptr::null_mut::<libc::c_char>();
    yy_init = 0 as libc::c_int;
    yy_start = 0 as libc::c_int;
    sudoersin = std::ptr::null_mut::<FILE>();
    sudoersout = std::ptr::null_mut::<FILE>();
    0 as libc::c_int
}
#[no_mangle]
pub fn sudoerslex_destroy() -> libc::c_int {
    unsafe {
        while !if !yy_buffer_stack.is_null() {
            *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
        } else {
            0 as YY_BUFFER_STATE
        }
        .is_null()
        {
            sudoers_delete_buffer(if !yy_buffer_stack.is_null() {
                *yy_buffer_stack.offset(yy_buffer_stack_top as isize)
            } else {
                0 as YY_BUFFER_STATE
            });
            let fresh26 = &mut *yy_buffer_stack.offset(yy_buffer_stack_top as isize);
            *fresh26 = 0 as YY_BUFFER_STATE;
            sudoerspop_buffer_state();
        }
        sudoersfree(yy_buffer_stack as *mut libc::c_void);
    }
    unsafe { yy_buffer_stack = std::ptr::null_mut::<YY_BUFFER_STATE>() };
    unsafe { yy_init_globals() };
    0 as libc::c_int
}
#[no_mangle]
pub unsafe fn sudoersalloc(mut size: yy_size_t) -> *mut libc::c_void {
    malloc(size)
}
#[no_mangle]
pub unsafe fn sudoersrealloc(mut ptr: *mut libc::c_void, mut size: yy_size_t) -> *mut libc::c_void {
    realloc(ptr as *mut libc::c_char as *mut libc::c_void, size)
}
#[no_mangle]
pub unsafe fn sudoersfree(mut ptr: *mut libc::c_void) {
    free(ptr as *mut libc::c_char as *mut libc::c_void);
}
